Hochladen von großen Archiven mithilfe des AWS SDK for .NET

Sowohl die High-Level-APIs als auch die Low-Level-APIs, die vom Amazon SDK for .NET bereitgestellt werden, bieten eine Methode, um große Archive in Teilen hochzuladen (sieheHochladen eines Archivs in Amazon S3 Glacier).

• Die High-Level-API bietet eine Methode, mit der Sie ein Archiv jeder Größe hochladen können. Abhängig von der Datei, die Sie hochladen, lädt die Methode das Archiv entweder in einem einzigen Vorgang hoch oder verwendet die Unterstützung für mehrteiliges Hochladen in Amazon S3 Glacier (S3 Glacier), um das Archiv in Teilen hochzuladen.

• Die Low-Level-API wird eng auf die zugrundeliegende REST-Implementierung abgebildet. Dem entsprechend wird eine Methode zum Hochladen kleiner Archive in einer Operation bereitgestellt und eine Gruppen von Methoden, die den mehrteiligen Upload größerer Archive unterstützen. In diesem Abschnitt wird das Hochladen großer Archive in Teilen mithilfe der Low-Level-API beschrieben.

Weitere Informationen zu High-Level- und Low-level-APIs finden Sie unter Verwendung derAWS SDK for .NETmit Amazon S3 Glacier.

Hochladen großer Archive in Teilen mithilfe der High-Level-API des AWS SDK for .NET

Sie verwenden die gleichen Methoden der High-Level-API für den Upload kleiner und großer Archive. Basierend auf der Archivgröße entscheiden die High-Level-API-Methoden, ob das Archiv in einem einzigen Vorgang hochgeladen oder die von S3 Glacier bereitgestellte mehrteilige Upload-API verwendet wird. Weitere Informationen finden Sie unter Hochladen eines Archivs mithilfe der High-Level-API von AWS SDK for .NET.

Hochladen großer Archive in Teilen mithilfe der Low-Level-API des AWS SDK for .NET

Zur präzisen Steuerung des Uploads können Sie das Low-Level-API verwenden, über das Sie die Anfrage konfigurieren und die Antwort bearbeiten können. Im Folgenden werden die Schritte zum Hochladen großer Archive in Teilen mit dem AWS SDK for .NET beschrieben.

1. Erstellen einer Instance der AmazonGlacierClient-Klasse (Client).

   Sie müssen eineAWS Region angeben, in der Sie das Archiv speichern möchten. Alle Operationen, die Sie mit diesem Client ausführen, gelten für dieseAWS Region.

2. Initiieren eines mehrteiligen Uploads durch Aufrufen der Methode InitiateMultipartUpload.

   Sie müssen den Namen des Tresors, in den Sie das Archiv hochladen möchten, die Größe der Teile, die Sie verwenden möchten, um Archivteile hochzuladen, und optional eine Beschreibung angeben. Diese Informationen stellen Sie bereit, indem Sie eine Instance der InitiateMultipartUploadRequest-Klasse erstellen. Als Antwort gibt S3 Glacier eine Upload-ID zurück.

3. Laden Sie Teile durch den Aufruf der UploadMultipartPart-Methode hoch.

   Für jeden hochgeladenen Teil müssen folgende Angaben gemacht werden: der Tresorname und Byte-Bereich im endgültig zusammengestellten Archiv, das in diesem Teil hochgeladen wird, sowie die Prüfsumme der Teildaten und die Upload-ID.

4. Führen Sie den mehrteiligen Upload aus, indem Sie die Methode CompleteMultipartUpload aufrufen.

   Sie müssen die Upload-ID, die Prüfsumme des gesamten Archivs, die Archivgröße (kombinierte Größe aller hochgeladenen Teile) und den Tresornamen angeben. S3 Glacier erstellt das Archiv aus den hochgeladenen Teilen und gibt eine Archiv-ID zurück.

Beispiel: Ein großes Archiv in Teilen mit dem Amazon SDK for .NET hochladen

Im folgenden C#-Codebeispiel wird das AWS SDK for .NET zum Hochladen eines Archivs in den Tresor verwendet (examplevault). step-by-step Anweisungen zur Ausführung dieses Beispiels finden Sie unterAusführen von Codebeispielen. Sie müssen den Code wie gezeigt mit dem Namen einer Datei aktualisieren, die Sie hochladen möchten.

using System;
using System.Collections.Generic;
using System.IO;
using Amazon.Glacier;
using Amazon.Glacier.Model;
using Amazon.Runtime;

namespace glacier.amazon.com.docsamples
{
  class ArchiveUploadMPU
  {
    static string vaultName       = "examplevault";
    static string archiveToUpload = "*** Provide file name (with full path) to upload ***";
    static long partSize          = 4194304; // 4 MB.

    public static void Main(string[] args)
    {
      AmazonGlacierClient client;
      List<string> partChecksumList = new List<string>();
      try
      {
         using (client = new AmazonGlacierClient(Amazon.RegionEndpoint.USWest2)) 
        {
          Console.WriteLine("Uploading an archive.");
          string uploadId  = InitiateMultipartUpload(client);
          partChecksumList = UploadParts(uploadId, client);
          string archiveId = CompleteMPU(uploadId, client, partChecksumList);
          Console.WriteLine("Archive ID: {0}", archiveId);
        }
        Console.WriteLine("Operations successful. To continue, press Enter");
        Console.ReadKey();
      }
      catch (AmazonGlacierException e) { Console.WriteLine(e.Message); }
      catch (AmazonServiceException e) { Console.WriteLine(e.Message); }
      catch (Exception e) { Console.WriteLine(e.Message); }
      Console.WriteLine("To continue, press Enter");
      Console.ReadKey();
    }

    static string InitiateMultipartUpload(AmazonGlacierClient client)
    {
      InitiateMultipartUploadRequest initiateMPUrequest = new InitiateMultipartUploadRequest()
      {

        VaultName = vaultName,
        PartSize = partSize,
        ArchiveDescription = "Test doc uploaded using MPU."
      };

      InitiateMultipartUploadResponse initiateMPUresponse = client.InitiateMultipartUpload(initiateMPUrequest);

      return initiateMPUresponse.UploadId;
    }

    static List<string> UploadParts(string uploadID, AmazonGlacierClient client)
    {
      List<string> partChecksumList = new List<string>();
      long currentPosition = 0;
      var buffer = new byte[Convert.ToInt32(partSize)];

      long fileLength = new FileInfo(archiveToUpload).Length;
      using (FileStream fileToUpload = new FileStream(archiveToUpload, FileMode.Open, FileAccess.Read))
      {
        while (fileToUpload.Position < fileLength)
        {
          Stream uploadPartStream = GlacierUtils.CreatePartStream(fileToUpload, partSize);
          string checksum = TreeHashGenerator.CalculateTreeHash(uploadPartStream);
          partChecksumList.Add(checksum);
          // Upload part.
          UploadMultipartPartRequest uploadMPUrequest = new UploadMultipartPartRequest()
          {

            VaultName = vaultName,
            Body = uploadPartStream,
            Checksum = checksum,
            UploadId = uploadID
          };
          uploadMPUrequest.SetRange(currentPosition, currentPosition + uploadPartStream.Length - 1);
          client.UploadMultipartPart(uploadMPUrequest);

          currentPosition = currentPosition + uploadPartStream.Length;
        }
      }
      return partChecksumList;
    }

    static string CompleteMPU(string uploadID, AmazonGlacierClient client, List<string> partChecksumList)
    {
      long fileLength = new FileInfo(archiveToUpload).Length;
      CompleteMultipartUploadRequest completeMPUrequest = new CompleteMultipartUploadRequest()
      {
        UploadId = uploadID,
        ArchiveSize = fileLength.ToString(),
        Checksum = TreeHashGenerator.CalculateTreeHash(partChecksumList),
        VaultName = vaultName
      };

      CompleteMultipartUploadResponse completeMPUresponse = client.CompleteMultipartUpload(completeMPUrequest);
      return completeMPUresponse.ArchiveId;
    }
  }
}