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.

# Übertragen Sie Verzeichnisse mit der AWS SDK für PHP Version 3 zu und von Amazon S3
<a name="s3-transfer"></a>

Sie verwenden die `Transfer` Klasse in AWS SDK für PHP Version 3, um ganze Verzeichnisse in einen Amazon S3 S3-Bucket hochzuladen und ganze Buckets in ein lokales Verzeichnis herunterzuladen.

## Ein lokales Verzeichnis auf Amazon S3 hochladen
<a name="uploading-a-local-directory-to-s3"></a>

Das [https://docs.aws.amazon.com/aws-sdk-php/v3/api/class-Aws.S3.Transfer.html](https://docs.aws.amazon.com/aws-sdk-php/v3/api/class-Aws.S3.Transfer.html)Objekt führt die Übertragungen durch. Das folgende Beispiel zeigt, wie ein lokales Dateiverzeichnis rekursiv in einen Amazon S3 S3-Bucket hochgeladen wird.

```
// Create an S3 client.
$client = new \Aws\S3\S3Client([
    'region'  => 'us-west-2',
    'version' => '2006-03-01',
]);

// Where the files will be sourced from.
$source = '/path/to/source/files';

// Where the files will be transferred to.
$dest = 's3://bucket';

// Create a transfer object.
$directoryTransfer = new \Aws\S3\Transfer($client, $source, $dest);

// Perform the transfer synchronously.
$directoryTransfer->transfer();
```

In diesem Beispiel haben wir einen Amazon S3 S3-Client erstellt, ein `Transfer` Objekt erstellt und die Übertragung synchron durchgeführt. 

Das vorherige Beispiel zeigt die Mindestmenge an Code, die für die Durchführung einer Übertragung erforderlich ist. Ein `Transfer` Objekt kann Übertragungen auch asynchron durchführen und verfügt über verschiedene Konfigurationsoptionen, mit denen Sie die Übertragungen anpassen können.

Sie können die lokalen Dateien in einen „Unterordner“ eines Amazon S3 S3-Buckets hochladen, indem Sie in der `s3://` URI ein key prefix angeben. Im folgenden Beispiel werden die lokalen Dateien auf dem Datenträger in den `bucket`-Bucket hochgeladen und die Dateien unter dem Schlüsselpräfix `foo` gespeichert.

```
$source = '/path/to/source/files';
$dest = 's3://bucket/foo';
$directoryTransfer = new \Aws\S3\Transfer($client, $source, $dest);
$directoryTransfer->transfer();
```

## Einen Amazon S3 S3-Bucket herunterladen
<a name="downloading-an-s3-bucket"></a>

Sie können einen Amazon S3 S3-Bucket rekursiv in ein lokales Verzeichnis auf der Festplatte herunterladen, indem Sie das `$source` Argument als Amazon S3 S3-URI (z. B.`s3://bucket`) und das `$dest` Argument als Pfad zu einem lokalen Verzeichnis angeben.

```
// Where the files will be sourced from.
$source = 's3://bucket';

// Where the files will be transferred to.
$dest = '/path/to/destination/dir';

$directoryTransfer = new \Aws\S3\Transfer($client, $source, $dest);
$directoryTransfer->transfer();
```

**Anmerkung**  
Das SDK erstellt automatisch alle erforderlichen Verzeichnisse, wenn die Objekte im Bucket heruntergeladen werden.

Sie können nach dem Bucket ein key prefix in die Amazon S3 S3-URI aufnehmen, um nur Objekte herunterzuladen, die in einem „Pseudoordner“ gespeichert sind. Das folgende Beispiel lädt nur Dateien herunter, die unter dem Schlüsselpräfix „/ foo“ des betreffenden Buckets gespeichert sind.

```
$source = 's3://bucket/foo';
$dest = '/path/to/destination/dir';
$directoryTransfer = new \Aws\S3\Transfer($client, $source, $dest);
$directoryTransfer->transfer();
```

## Konfiguration
<a name="configuration"></a>

Der `Transfer`-Objektkonstruktor akzeptiert die folgenden Argumente:

** `$client` **  
Das `Aws\ClientInterface`-Objekt für die Ausführung der Übertragungen.

** `$source`(Zeichenfolge \$1) `Iterator`**  
Die zu übertragenden Quelldaten. Dies kann auf einen lokalen Pfad auf der Festplatte (z. B.`/path/to/files`) oder auf einen Amazon S3 S3-Bucket (z. B.`s3://bucket`) verweisen. Die `s3://`-URI kann auch ein Schlüsselpräfix enthalten, das verwendet werden kann, um nur Objekte unter einem gemeinsamen Präfix zu übertragen.  
Wenn das `$source` Argument ein Amazon S3 S3-URI ist, muss das `$dest` Argument ein lokales Verzeichnis sein (und umgekehrt).  
Neben der Bereitstellung eines Zeichenfolgenwerts können Sie auch ein `\Iterator`-Objekt angeben, das absolute Dateinamen erzeugt. Wenn Sie ein `\Iterator` Objekt angeben, **müssen** Sie eine `base_dir` Option im `$options` assoziativen Array angeben.

** `$dest` **  
Das Ziel, an das die Dateien übertragen werden. Wenn das `$source` Argument ein lokaler Pfad auf der Festplatte ist, `$dest` muss es sich um einen Amazon S3 S3-Bucket-URI handeln (z. B.`s3://bucket`). Wenn das `$source` Argument ein Amazon S3 S3-Bucket-URI ist, muss das `$dest` Argument ein lokaler Pfad auf der Festplatte sein.

** `$options` **  
Ein assoziatives Array mit Übertragungsoptionen. Die folgenden Übertragungsoptionen sind gültig:    
**`add_content_md5` (bool)**  
Wird auf gesetzt`true`, um die MD5 Prüfsumme für Uploads zu berechnen.  
** `base_dir` (string)**  
Basisverzeichnis der Quelle, wenn `$source` ein Iterator ist. Wenn die `$source`-Option kein Array ist, wird diese Option ignoriert.  
** `before` (aufrufbar)**  
Ein Callback, der vor jeder Übertragung aufgerufen wird. Der Callback sollte eine Funktionssignatur wie `function (Aws\Command $command) {...}` haben. Der bereitgestellte Befehl ist `GetObject``PutObject`, `CreateMultipartUpload`, `UploadPart` oder `CompleteMultipartUpload`.  
** `mup_threshold` (int)**  
Größe in Bytes, für die ein mehrteiliger Upload statt `PutObject` verwendet werden soll. Standardwert `16777216` (16 MB).  
** `concurrency` (int, default=5)**  
Anzahl der Dateien, die gleichzeitig hochgeladen werden. Die ideale Nebenläufigkeitswert variiert abhängig von der Anzahl der Dateien, die hochgeladen werden, und der durchschnittlichen Größe der einzelnen Datei. Im Allgemeinen profitieren kleinere Dateien von einer höheren Nebenläufigkeit, während größere Dateien dies nicht tun.  
** `debug` (bool)**  
Auf `true` setzen, um Debugging-Informationen für Übertragungen auszugeben. Auf eine `fopen()`-Ressource setzen, um statt auf STDOUT in einen bestimmten Stream zu schreiben.

## Asynchrone Übertragungen
<a name="async-transfers"></a>

Das `Transfer`-Objekt ist eine Instance von `GuzzleHttp\Promise\PromisorInterface`. Das bedeutet, dass die Übertragung asynchron stattfinden kann und durch Aufruf der `promise`-Methode des Objekts ausgelöst wird.

```
$source = '/path/to/source/files';
$dest = 's3://bucket';
$directoryTransfer = new \Aws\S3\Transfer($client, $source, $dest);

// Initiate the transfer and get a promise.
$promise = $directoryTransfer->promise();

// Do something when the transfer is complete using the then() method.
$promise->then(function () {
    echo 'Done!';
});
```

Das Versprechen wird abgelehnt, wenn eine Datei nicht übertragen werden kann. Sie können die fehlgeschlagene Übertragung asynchron unter Verwendung der `otherwise`-Methode des Promise verarbeiten. Die `otherwise`-Funktion akzeptiert einen Callback, der aufgerufen wird, wenn ein Fehler auftritt. Der Rückruf akzeptiert das `$reason` für die Ablehnung, was normalerweise eine Instanz von ist `Aws\Exception\AwsException` (obwohl ein **beliebiger** Wert an den Rückruf übergeben werden kann).

```
$promise->otherwise(function ($reason) {
    echo 'Transfer failed: ';
    var_dump($reason);
});
```

Da das `Transfer`-Objekt ein Promise zurückgibt, können diese Übertragungen gleichzeitig mit anderen asynchronen Promises stattfinden.

## Anpassen der Verzeichnisübertragung
<a name="customizing-the-transfer-manager-s-commands"></a>

Indem Sie dem Konstruktor einen Callback hinzufügen, können Sie die Optionen anpassen, die der Konstruktor ausführt. `Transfer`

```
$uploader = new Transfer($s3Client, $source, $dest, [
    'before' => function (\Aws\Command $command) {
        // Commands can vary for multipart uploads, so check which command
        // is being processed.
        if (in_array($command->getName(), ['PutObject', 'CreateMultipartUpload'])) {
            // Set custom cache-control metadata.
            $command['CacheControl'] = 'max-age=3600';
            // Apply a canned ACL.
            $command['ACL'] = strpos($command['Key'], 'CONFIDENTIAL') ### false
                ? 'public-read'
                : 'private';
        }
    },
]);
```