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

Sowohl die High-Level- als auch die Low-Level-API, die vom Amazon-SDK für .NET bereitgestellt werden, bieten eine Methode zum Hochladen großer Archive in Teilen (siehe Hochladen eines Archivs in Amazon S3 Glacier).

• Die High-Level-API bietet eine Methode, mit der Sie ein Archiv jeder Größe hochladen können. Die Größe der hochzuladenden Datei entscheidet bei dieser Methode darüber, ob ein Archiv in einer einzigen Operation hochgeladen wird oder ob die Unterstützung für mehrteilige Uploads in Amazon S3 Glacier (S3 Glacier) verwendet wird, um das Archiv in mehreren 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 Verwenden von AWS SDK for .NET mit 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. Auf Grundlage der Archivgröße bestimmen die High-Level-API-Methoden, ob das Archiv in einer einzigen Operation oder mithilfe der von S3 Glacier bereitgestellten API für mehrteilige Uploads hochgeladen 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 die AWS-Region angeben, in der das Archiv gespeichert werden soll. Alle Operationen, die Sie mit diesem Client ausführen, gelten für diese AWS-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 bereitstellen. S3 Glacier stellt das Archiv aus den hochgeladenen Teilen zusammen und gibt eine Archiv-ID zurück.

Beispiel: Hochladen eines großen Archivs in Teilen mithilfe des Amazon-SDK für .NET

Im folgenden C#-Codebeispiel wird das AWS SDK for .NET zum Hochladen eines Archivs in den Tresor verwendet (examplevault). Eine schrittweise Anleitung für das Ausführen dieses Beispiels finden Sie unter Ausführen von Codebeispielen. Sie müssen den Code wie gezeigt mit dem Namen einer hochzuladenden Datei aktualisieren.

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