**Diese Seite ist nur für Bestandskunden des Amazon Glacier-Service bestimmt, die Vaults und die ursprüngliche REST-API von 2012 verwenden.**

Wenn Sie nach Archivspeicherlösungen suchen, empfehlen wir die Verwendung der Amazon Glacier-Speicherklassen in Amazon S3, S3 Glacier Instant Retrieval, S3 Glacier Flexible Retrieval und S3 Glacier Deep Archive. Weitere Informationen zu diesen Speicheroptionen finden Sie unter [Amazon Glacier-Speicherklassen](https://aws.amazon.com/s3/storage-classes/glacier/).

Amazon Glacier (ursprünglicher eigenständiger, auf Tresor basierender Service) akzeptiert keine Neukunden mehr. Amazon Glacier ist ein eigenständiger Service APIs , der Daten in Tresoren speichert und sich von den Speicherklassen Amazon S3 und Amazon S3 Glacier unterscheidet. Ihre vorhandenen Daten bleiben in Amazon Glacier auf unbestimmte Zeit sicher und zugänglich. Es ist keine Migration erforderlich. Für kostengünstige, langfristige Archivierungsspeicherung AWS empfiehlt sich die [Amazon S3 Glacier-Speicherklasse](https://aws.amazon.com/s3/storage-classes/glacier/), die mit S3-Bucket-Basis, voller AWS-Region Verfügbarkeit APIs, geringeren Kosten und AWS Serviceintegration ein hervorragendes Kundenerlebnis bieten. Wenn Sie erweiterte Funktionen wünschen, sollten Sie eine Migration zu Amazon S3 Glacier-Speicherklassen in Betracht ziehen, indem Sie unseren [AWS Lösungsleitfaden für die Übertragung von Daten aus Amazon Glacier-Tresoren in Amazon S3 Glacier-Speicherklassen](https://aws.amazon.com/solutions/guidance/data-transfer-from-amazon-s3-glacier-vaults-to-amazon-s3/) verwenden.

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.

# Berechnen von Prüfsummen
<a name="checksum-calculations"></a>

Bei einem Archiv-Upload müssen die Header `x-amz-sha256-tree-hash` und `x-amz-content-sha256` enthalten sein. Der `x-amz-sha256-tree-hash`-Header ist eine Prüfsumme der Nutzlast in Ihrem Anfragetext. In diesem Thema wird die Berechnung des `x-amz-sha256-tree-hash`-Headers beschrieben. Der `x-amz-content-sha256`-Header ist ein Hash der gesamten Nutzlast und ist für die Autorisierung erforderlich. Weitere Informationen finden Sie unter [Signatur-Berechnungsbeispiel für die Streaming-API](amazon-glacier-signing-requests.md#example-signature-calculation-streaming). 

Die Nutzlast Ihrer Anfrage kann Folgendes sein:

 
+ **Gesamtes Archiv**: Wenn Sie ein Archiv in einer einzelnen Anforderung mit der API „Upload Archive“ hochladen, wird das gesamte Archiv im Anforderungstext gesendet. In diesem Fall muss die Prüfsumme des gesamten Archivs enthalten sein. 
+ **Archivteile**: Wenn Sie ein Archiv mit der API „Multipart Upload“ in Teilen hochladen, senden Sie nur einen Teil des Archivs im Anforderungstext. In diesem Fall ist die Prüfsumme des Archivteils enthalten. Nachdem Sie alle Teile hochgeladen haben, senden Sie eine „Complete Multipart Upload“-Anfrage, in der die Prüfsumme des gesamten Archivs enthalten sein muss.

Die Prüfsumme für die Nutzlast ist ein SHA-256-Struktur-Hash. Dies wird als Struktur-Hash bezeichnet, da bei der Berechnung der Prüfsumme die Struktur eines SHA-256-Hash-Werts berechnet wird. Der Hash-Wert am Stamm ist die Prüfsumme des gesamten Archivs. 

 

**Anmerkung**  
In diesem Abschnitt wird eine Möglichkeit zur Berechnung des SHA-256-Struktur-Hashs beschrieben. Allerdings können Sie einen beliebigen Vorgang verwenden, bei dem das gleiche Ergebnis erzielt wird.

Der SHA-256-Struktur-Hash wird wie folgt berechnet:

 

1. Berechnen Sie den SHA-256-Hash für jeden 1 MB großen Teil der Nutzlastdaten. Der letzte Datenanteil kann kleiner als 1 MB sein. Wenn Sie beispielsweise ein Archiv mit 3,2 MB hochladen, berechnen Sie die SHA-256-Hash-Werte für jeden der ersten drei 1 MB großen Datenstücke und berechnen dann den SHA-256-Hash der verbleibenden 0,2 MB Daten. Diese Hash-Werte formen die Blattknoten der Baumstruktur.

1. Erstellen Sie die nächste Ebene der Baumstruktur.

   1. Verketten Sie die Hash-Werte von zwei aufeinanderfolgenden untergeordneten Knoten und berechnen Sie den SHA-256-Wert der verketteten Hash-Werte. Durch diese Verkettung und Erstellung des SHA-256-Hashs wird ein übergeordneten Knoten für die beiden untergeordneten Knoten erstellt.

   1. Wenn nur ein untergeordneter Knoten übrig bleibt, stufen Sie diesen Hash-Wert auf die nächste Ebene in der Baumstruktur hoch.

1. Wiederholen Sie Schritt 2, bis die sich daraus ergebende Struktur einen Stamm hat. Der Stamm der Baumstruktur stellt einen Hash des gesamten Archivs bereit und ein Stamm der entsprechenden Nebenstruktur stellt den Hash des Teils eines mehrteiligen Uploads bereit. 

**Topics**
+ [Struktur-Hash-Beispiel 1: Hochladen eines Archivs in einer einzelnen Anfrage](#checksum-calculations-upload-archive-in-single-payload)
+ [Struktur-Hash-Beispiel 2: Hochladen eines Archivs mit einem mehrteiligen Upload](#checksum-calculations-upload-archive-using-mpu)
+ [Berechnen des Struktur-Hashs einer Datei](#checksum-calculations-examples)
+ [Erhalten von Prüfsummen bei Daten-Download](checksum-calculations-range.md)

## Struktur-Hash-Beispiel 1: Hochladen eines Archivs in einer einzelnen Anfrage
<a name="checksum-calculations-upload-archive-in-single-payload"></a>

Wenn Sie ein Archiv in einer einzelnen Anfrage mit der „Upload Archive“-API hochladen (Informationen dazu unter [Upload Archive (POST archive)](api-archive-post.md)), ist das gesamte Archiv in der Anfragenutzlast enthalten. Dem entsprechend muss der Struktur-Hash des gesamten Archivs im `x-amz-sha256-tree-hash`-Anfrage-Header enthalten sein. Angenommen, Sie möchten ein Archiv mit 6,5 MB hochladen. Das folgende Diagramm verdeutlicht den Vorgang zur Erstellung eines SHA-256-Hashs für das Archiv. Sie lesen das Archiv und berechnen den SHA-256-Hash für jeden 1 MB große Teil. Sie berechnen den Hash für die 0,5 MB der verbleiben Daten und erstellen die Struktur wie in den folgenden Schritten beschrieben.

 

![\[Diagramm, das ein Tree-Hash-Beispiel zeigt, das ein Archiv in einer einzigen Anfrage hochlädt.\]](http://docs.aws.amazon.com/de_de/amazonglacier/latest/dev/images/TreeHash-ArchiveUploadSingleRequest.png)


## Struktur-Hash-Beispiel 2: Hochladen eines Archivs mit einem mehrteiligen Upload
<a name="checksum-calculations-upload-archive-using-mpu"></a>

Der Vorgang zur Berechnung des Struktur-Hashs beim Upload eines Archivs mittels mehrteiligem Upload entspricht dem Archiv-Upload in einer einzelnen Anfrage. Der einzige Unterschied besteht darin, dass bei einem mehrteiligen Upload in jeder Anfrage (mit der [Upload Part (PUT uploadID)](api-upload-part.md)-API) nur ein Teil des Archivs hochgeladen wird, und Sie daher die Prüfsumme nur dieses Teils im `x-amz-sha256-tree-hash`-Anfrage-Header bereitstellen. Nachdem alle Teile hochgeladen wurden, müssen Sie allerdings die „Complete Multipart Upload“-Anfrage senden (Informationen unter [Complete Multipart Upload (POST uploadID)](api-multipart-complete-upload.md)), wobei der Struktur-Hash des gesamten Archivs im `x-amz-sha256-tree-hash`-Anfrage-Header enthalten ist. 

 

![\[Diagramm mit einem Baum-Hash-Beispiel für das Hochladen eines Archivs mithilfe eines mehrteiligen Uploads.\]](http://docs.aws.amazon.com/de_de/amazonglacier/latest/dev/images/TreeHash-MPU.png)


## Berechnen des Struktur-Hashs einer Datei
<a name="checksum-calculations-examples"></a>

Die hier gezeigten Algorithmen wurden zu Demonstrationszwecken ausgewählt. Sie können den Code nach Bedarf für Ihr Implementierungsszenario optimieren. Wenn Sie ein Amazon SDK verwenden, um gegen Amazon Glacier (Amazon Glacier) zu programmieren, wird die Baum-Hash-Berechnung für Sie durchgeführt und Sie müssen nur die Dateireferenz angeben.

**Example 1: Java-Beispiel**  
Das folgende Beispiel zeigt, wie der SHA256 Baumhash einer Datei mithilfe von Java berechnet wird. Sie können dieses Beispiel entweder ausführen, indem Sie den Speicherort einer Datei als ein Argument angeben, oder Sie können die `TreeHashExample.computeSHA256TreeHash`-Methode direkt aus Ihrem Code verwenden.  

```
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;

public class TreeHashExample {

static final int ONE_MB = 1024 * 1024;

    /**
     * Compute the Hex representation of the SHA-256 tree hash for the specified
     * File
     * 
     * @param args
     *            args[0]: a file to compute a SHA-256 tree hash for
     */
    public static void main(String[] args) {

        if (args.length < 1) {
            System.err.println("Missing required filename argument");
            System.exit(-1);
        }

        File inputFile = new File(args[0]);
        try {

            byte[] treeHash = computeSHA256TreeHash(inputFile);
            System.out.printf("SHA-256 Tree Hash = %s\n", toHex(treeHash));

        } catch (IOException ioe) {
            System.err.format("Exception when reading from file %s: %s", inputFile,
                    ioe.getMessage());
            System.exit(-1);

        } catch (NoSuchAlgorithmException nsae) {
            System.err.format("Cannot locate MessageDigest algorithm for SHA-256: %s",
                    nsae.getMessage());
            System.exit(-1);
        }
    }

    /**
     * Computes the SHA-256 tree hash for the given file
     * 
     * @param inputFile
     *            a File to compute the SHA-256 tree hash for
     * @return a byte[] containing the SHA-256 tree hash
     * @throws IOException
     *             Thrown if there's an issue reading the input file
     * @throws NoSuchAlgorithmException
     */
    public static byte[] computeSHA256TreeHash(File inputFile) throws IOException,
            NoSuchAlgorithmException {

        byte[][] chunkSHA256Hashes = getChunkSHA256Hashes(inputFile);
        return computeSHA256TreeHash(chunkSHA256Hashes);
    }

    /**
     * Computes a SHA256 checksum for each 1 MB chunk of the input file. This
     * includes the checksum for the last chunk even if it is smaller than 1 MB.
     * 
     * @param file
     *            A file to compute checksums on
     * @return a byte[][] containing the checksums of each 1 MB chunk
     * @throws IOException
     *             Thrown if there's an IOException when reading the file
     * @throws NoSuchAlgorithmException
     *             Thrown if SHA-256 MessageDigest can't be found
     */
    public static byte[][] getChunkSHA256Hashes(File file) throws IOException,
            NoSuchAlgorithmException {

        MessageDigest md = MessageDigest.getInstance("SHA-256");

        long numChunks = file.length() / ONE_MB;
        if (file.length() % ONE_MB > 0) {
            numChunks++;
        }

        if (numChunks == 0) {
            return new byte[][] { md.digest() };
        }

        byte[][] chunkSHA256Hashes = new byte[(int) numChunks][];
        FileInputStream fileStream = null;

        try {
            fileStream = new FileInputStream(file);
            byte[] buff = new byte[ONE_MB];

            int bytesRead;
            int idx = 0;
            int offset = 0;

            while ((bytesRead = fileStream.read(buff, offset, ONE_MB)) > 0) {
                md.reset();
                md.update(buff, 0, bytesRead);
                chunkSHA256Hashes[idx++] = md.digest();
                offset += bytesRead;
            }

            return chunkSHA256Hashes;

        } finally {
            if (fileStream != null) {
                try {
                    fileStream.close();
                } catch (IOException ioe) {
                    System.err.printf("Exception while closing %s.\n %s", file.getName(),
                            ioe.getMessage());
                }
            }
        }
    }

    /**
     * Computes the SHA-256 tree hash for the passed array of 1 MB chunk
     * checksums.
     * 
     * This method uses a pair of arrays to iteratively compute the tree hash
     * level by level. Each iteration takes two adjacent elements from the
     * previous level source array, computes the SHA-256 hash on their
     * concatenated value and places the result in the next level's destination
     * array. At the end of an iteration, the destination array becomes the
     * source array for the next level.
     * 
     * @param chunkSHA256Hashes
     *            An array of SHA-256 checksums
     * @return A byte[] containing the SHA-256 tree hash for the input chunks
     * @throws NoSuchAlgorithmException
     *             Thrown if SHA-256 MessageDigest can't be found
     */
    public static byte[] computeSHA256TreeHash(byte[][] chunkSHA256Hashes)
            throws NoSuchAlgorithmException {

        MessageDigest md = MessageDigest.getInstance("SHA-256");

        byte[][] prevLvlHashes = chunkSHA256Hashes;

        while (prevLvlHashes.length > 1) {

            int len = prevLvlHashes.length / 2;
            if (prevLvlHashes.length % 2 != 0) {
                len++;
            }

            byte[][] currLvlHashes = new byte[len][];

            int j = 0;
            for (int i = 0; i < prevLvlHashes.length; i = i + 2, j++) {

                // If there are at least two elements remaining
                if (prevLvlHashes.length - i > 1) {

                    // Calculate a digest of the concatenated nodes
                    md.reset();
                    md.update(prevLvlHashes[i]);
                    md.update(prevLvlHashes[i + 1]);
                    currLvlHashes[j] = md.digest();

                } else { // Take care of remaining odd chunk
                    currLvlHashes[j] = prevLvlHashes[i];
                }
            }

            prevLvlHashes = currLvlHashes;
        }

        return prevLvlHashes[0];
    }

    /**
     * Returns the hexadecimal representation of the input byte array
     * 
     * @param data
     *            a byte[] to convert to Hex characters
     * @return A String containing Hex characters
     */
    public static String toHex(byte[] data) {
        StringBuilder sb = new StringBuilder(data.length * 2);

        for (int i = 0; i < data.length; i++) {
            String hex = Integer.toHexString(data[i] & 0xFF);

            if (hex.length() == 1) {
                // Append leading zero.
                sb.append("0");
            }
            sb.append(hex);
        }
        return sb.toString().toLowerCase();
    }
}
```

**Example 2: C\$1 .NET-Beispiel**  
Das folgende Beispiel zeigt, wie der SHA256 Baumhash einer Datei berechnet wird. Sie können dieses Beispiel ausführen, indem Sie den Speicherort der Datei als Argument angeben.  

```
using System;
using System.IO;

using System.Security.Cryptography;

namespace ExampleTreeHash
{
    class Program
    {
        static int ONE_MB = 1024 * 1024;

        /**
        * Compute the Hex representation of the SHA-256 tree hash for the
        * specified file
        * 
        * @param args
        *            args[0]: a file to compute a SHA-256 tree hash for
        */
        public static void Main(string[] args)
        {
            if (args.Length < 1)
            {
                Console.WriteLine("Missing required filename argument");
                Environment.Exit(-1);
            }
            FileStream inputFile = File.Open(args[0], FileMode.Open, FileAccess.Read);
            try
            {
                byte[] treeHash = ComputeSHA256TreeHash(inputFile);
                Console.WriteLine("SHA-256 Tree Hash = {0}", BitConverter.ToString(treeHash).Replace("-", "").ToLower());
                Console.ReadLine();
                Environment.Exit(-1);
            }
            catch (IOException ioe)
            {
                Console.WriteLine("Exception when reading from file {0}: {1}",
                    inputFile, ioe.Message);
                Console.ReadLine();
                Environment.Exit(-1);
            }
            catch (Exception e)
            {
                Console.WriteLine("Cannot locate MessageDigest algorithm for SHA-256: {0}",
                    e.Message);
                Console.WriteLine(e.GetType());
                Console.ReadLine();
                Environment.Exit(-1);
            }
            Console.ReadLine();
        }


        /**
         * Computes the SHA-256 tree hash for the given file
         * 
         * @param inputFile
         *            A file to compute the SHA-256 tree hash for
         * @return a byte[] containing the SHA-256 tree hash
         */
        public static byte[] ComputeSHA256TreeHash(FileStream inputFile)
        {
            byte[][] chunkSHA256Hashes = GetChunkSHA256Hashes(inputFile);
            return ComputeSHA256TreeHash(chunkSHA256Hashes);
        }


        /**
         * Computes a SHA256 checksum for each 1 MB chunk of the input file. This
         * includes the checksum for the last chunk even if it is smaller than 1 MB.
         * 
         * @param file
         *            A file to compute checksums on
         * @return a byte[][] containing the checksums of each 1MB chunk
         */
        public static byte[][] GetChunkSHA256Hashes(FileStream file)
        {
            long numChunks = file.Length / ONE_MB;
            if (file.Length % ONE_MB > 0)
            {
                numChunks++;
            }

            if (numChunks == 0)
            {
                return new byte[][] { CalculateSHA256Hash(null, 0) };
            }
            byte[][] chunkSHA256Hashes = new byte[(int)numChunks][];

            try
            {
                byte[] buff = new byte[ONE_MB];

                int bytesRead;
                int idx = 0;

                while ((bytesRead = file.Read(buff, 0, ONE_MB)) > 0)
                {
                    chunkSHA256Hashes[idx++] = CalculateSHA256Hash(buff, bytesRead);
                }
                return chunkSHA256Hashes;
            }
            finally
            {
                if (file != null)
                {
                    try
                    {
                        file.Close();
                    }
                    catch (IOException ioe)
                    {
                        throw ioe;
                    }
                }
            }

        }

        /**
         * Computes the SHA-256 tree hash for the passed array of 1MB chunk
         * checksums.
         * 
         * This method uses a pair of arrays to iteratively compute the tree hash
         * level by level. Each iteration takes two adjacent elements from the
         * previous level source array, computes the SHA-256 hash on their
         * concatenated value and places the result in the next level's destination
         * array. At the end of an iteration, the destination array becomes the
         * source array for the next level.
         * 
         * @param chunkSHA256Hashes
         *            An array of SHA-256 checksums
         * @return A byte[] containing the SHA-256 tree hash for the input chunks
         */
        public static byte[] ComputeSHA256TreeHash(byte[][] chunkSHA256Hashes)
        {
            byte[][] prevLvlHashes = chunkSHA256Hashes;
            while (prevLvlHashes.GetLength(0) > 1)
            {

                int len = prevLvlHashes.GetLength(0) / 2;
                if (prevLvlHashes.GetLength(0) % 2 != 0)
                {
                    len++;
                }

                byte[][] currLvlHashes = new byte[len][];

                int j = 0;
                for (int i = 0; i < prevLvlHashes.GetLength(0); i = i + 2, j++)
                {

                    // If there are at least two elements remaining
                    if (prevLvlHashes.GetLength(0) - i > 1)
                    {

                        // Calculate a digest of the concatenated nodes
                        byte[] firstPart = prevLvlHashes[i];
                        byte[] secondPart = prevLvlHashes[i + 1];
                        byte[] concatenation = new byte[firstPart.Length + secondPart.Length];
                        System.Buffer.BlockCopy(firstPart, 0, concatenation, 0, firstPart.Length);
                        System.Buffer.BlockCopy(secondPart, 0, concatenation, firstPart.Length, secondPart.Length);

                        currLvlHashes[j] = CalculateSHA256Hash(concatenation, concatenation.Length);

                    }
                    else
                    { // Take care of remaining odd chunk
                        currLvlHashes[j] = prevLvlHashes[i];
                    }
                }

                prevLvlHashes = currLvlHashes;
            }

            return prevLvlHashes[0];
        }

        public static byte[] CalculateSHA256Hash(byte[] inputBytes, int count)
        {
            SHA256 sha256 = System.Security.Cryptography.SHA256.Create();
            byte[] hash = sha256.ComputeHash(inputBytes, 0, count);
            return hash;
        }
    }
}
```

# Erhalten von Prüfsummen bei Daten-Download
<a name="checksum-calculations-range"></a>

Beim Abrufen eines Archivs mit der „Initiate Job“-API (Informationen unter [Initiate Job (POST jobs)](api-initiate-job-post.md)) können Sie optional einen abzurufenden Bereich des Archivs angeben. Beim Abrufen eines Archivs mit der „Get Job Output“-API (Informationen unter [Get Job Output (GET output)](api-job-output-get.md)) können Sie optional einen abzurufenden Bereich des Archivs angeben. Es ist wichtig, dass Sie zwei Merkmale dieser Bereiche verstehen, wenn Sie Ihre Archivdaten abrufen und herunterladen. Der abzurufende Bereich muss durch *Megabytewerte* auf das Archiv beziehen. Sowohl der abzurufende als auch der herunterzuladende Bereich muss sich durch *Struktur-Hash-Werte* zuordnen lassen, um die Werte der Prüfsumme zu erhalten, wenn Sie Ihre Daten herunterladen. Die beiden Typen der Bereichszuordnung werden wie folgt definiert:

 
+ Auf Megabyte ausgerichtet — Ein Bereich [*StartByte*, *EndBytes*] ist auf Megabyte (1024\$11024) ausgerichtet, wenn er durch 1 MB teilbar *StartBytes*ist und *EndBytes*plus 1 durch 1 MB teilbar ist oder dem Ende des angegebenen Archivs entspricht (Archivbytegröße minus 1). Ein in der „Initiate Job“-API verwendeter Bereich, sofern angegeben, muss durch Megabytewerte zugeordnet sein.
+ Tree-Hash Aligned — Ein Bereich [*StartBytes*, *EndBytes*] ist ein Baumhash, der in Bezug auf ein Archiv ausgerichtet ist, genau dann, wenn die Wurzel des über den Bereich erstellten Baum-Hashes einem Knoten im Baumhash des gesamten Archivs entspricht. Sowohl der abzurufende als auch der herunterzuladende Bereich muss durch Struktur-Hash-Werte zugeordnet sein, um die Werte der Prüfsumme für Ihre heruntergeladenen Daten zu erhalten. Ein Beispiel für Bereiche und deren Beziehungen zum Archiv-Struktur-Hash finden Sie unter [Struktur-Hash-Beispiel: Abrufen eines durch Struktur-Hash-Werte zugeordneten Archivbereichs](#checksum-calculations-upload-archive-with-ranges). 

  Beachten Sie, dass ein durch Struktur-Hash-Werte zugeordneter Bereich zudem durch Megabyte-Werte zugeordnet ist. Ein durch Megabyte-Werte zugeordneter Bereich ist allerdings nicht notwendigerweise durch Struktur-Hash-Werte zugeordnet. 

Mit den folgenden Fällen wird beschreiben, wann Sie beim Download Ihrer Archivdaten einen Prüfsummenwert erhalten:

 
+ Wenn Sie in der „Initiate Job“-Anfrage keinen abzurufenden Bereich angeben und das gesamte Archiv in der „Get Job“-Anfrage herunterladen. 
+ Wenn Sie in der „Initiate Job“-Anfrage keinen abzurufenden Bereich angeben und einen durch Struktur-Hash-Werte zugeordneten Bereich zum Download in der „Get Job“-Anfrage angeben.
+ Wenn Sie in der „Initiate Job“-Anfrage keinen durch Struktur-Hash-Werte zugeordneten Bereich angeben und den gesamten Bereich in der „Get Job“-Anfrage herunterladen. 
+ Wenn Sie in der „Initiate Job“-Anfrage einen durch Struktur-Hash-Werte zugeordneten Bereich angeben und einen durch Struktur-Hash-Werte zugeordneten Bereich zum Download in der „Get Job“-Anfrage angeben. 

Wenn Sie einen abzurufenden Bereich in der „Initiate Job“-Anfrage angeben, der nicht auf ein Struktur-Hash bezogen ist, dann können Sie Ihre Archivdaten dennoch abrufen, aber es werden keine Prüfsummenwerte zurückgegeben, wenn Sie die Daten in der „Get Job“-Anfrage herunterladen.

## Struktur-Hash-Beispiel: Abrufen eines durch Struktur-Hash-Werte zugeordneten Archivbereichs
<a name="checksum-calculations-upload-archive-with-ranges"></a>

Angenommen, es ist ein 6,5 MB großes Archiv in Ihrem Tresor vorhanden und Sie möchten 2 MB des Archivs abrufen. Wie Sie den 2-MB-Bereich in der „Initiate Job“-Anfrage angeben, bestimmt, ob Sie beim Download der Daten Prüfsummenwerte für die Daten erhalten. Im folgenden Diagramm werden zwei 2 MB große Bereiche für 6,5 MB große Archive dargestellt, die heruntergeladen werden können. Beide Bereiche sind durch Megabyte-Werte zugeordnet, aber nur eins ist durch Struktur-Hash-Werte zugeordnet. 

 

![\[Diagramm, das den Abruf eines Archivbereichs zeigt, der an einem Baum-Hash ausgerichtet ist.\]](http://docs.aws.amazon.com/de_de/amazonglacier/latest/dev/images/TreeHash-ArchiveWithRanges.png)


## Durch Struktur-Hash-Werte zugeordnet Bereichsangabe
<a name="tree-hash-algorithm"></a>

In diesem Abschnitt wird genau angegeben, was einen durch Struktur-Hash-Werte zugeordneten Bereich ausmacht. Durch Struktur-Hash-Werte zugeordnete Bereiche sind wichtig, wenn Sie einen Teil eines Archivs herunterladen und Sie den abzurufenden Datenbereich und den herunterzuladenden Bereich aus den abgerufenen Daten angeben. Wenn diese beiden Bereiche durch Struktur-Hash-Werte zugeordnet sind, erhalten Sie beim Download der Daten Prüfsummendaten. 

Ein Bereich [*A*, *B*] gilt nur dann hinsichtlich eines Archiv als *durch Struktur-Hash-Werte zugeordnet*, wenn ein neuer Struktur-Hash über [*A*, *B*] des Stamm des für den Bereich erstellten Struktur-Hashs einem Knoten in dem Struktur-Hash des gesamten Archivs entspricht. Dies wird im Diagramm in [Struktur-Hash-Beispiel: Abrufen eines durch Struktur-Hash-Werte zugeordneten Archivbereichs](#checksum-calculations-upload-archive-with-ranges) verdeutlicht. In diesem Abschnitt werden die Angaben für Struktur-Hash-Zuordnung bereitgestellt.

Beachten Sie [*P*, *Q*] als die Bereichsabfrage für ein Archiv von *N* Megabyte (MB). Wobei *P* sowie *Q* Mehrfache eines MB sind. Beachten Sie, dass der tatsächliche eingeschlossene Bereich [*P* MB, *Q* MB - 1 Byte] ist. Zur Vereinfachung zeigen wir dies allerdings als [*P*, *Q*]. Demnach ergibt sich Folgendes:

 
+ Wenn *P* eine ungerade Zahl ist, gibt es nur einen möglichen Bereich, der dem Struktur-Hash zugeordnet ist, nämlich [*P*, *P* \$1 1 MB).
+ Wenn *P* eine gerade Zahl und *k* die der Maximalwert ist, wobei *P* als 2*k* \$1 *X* geschrieben werden kann, dann sind höchstens *k* dem Struktur-Hash-Werte zugeordnete Bereiche möglich, die mit *P* beginnen. *X* ist eine Ganzzahl größer 0. Die durch Struktur-Hash-Werte zugeordneten Bereiche fallen in folgende Kategorien: 
  + Für jedes *i*, wobei (0 <= *i* <= *k*) ist und *P* \$1 2*i* < *N* ist, dann ist [*P*, *Q* \$1 2*i*] ein durch Struktur-Hash-Werte zugeordneter Bereich.
  + *P* = 0 ist ein besonderer Fall, bei dem *A* = 2[lgN]\$10 ist.