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.

# Mehrteilige Amazon S3 S3-Uploads mit AWS SDK für PHP Version 3 verwenden
<a name="s3-multipart-upload"></a>

In einer einzelnen `PutObject`-Operation können Sie Objekte bis zu einer Größe von 5 GB hochladen. Durch Verwendung der Methoden für mehrteilige Uploads (z. B. `CreateMultipartUpload`, `UploadPart`, `CompleteMultipartUpload`, `AbortMultipartUpload`) können Sie jedoch Objekte von 5 MB bis 5 TB Größe hochladen.

Das folgende Beispiel zeigt eine Anleitung für:
+ Laden Sie ein Objekt auf Amazon S3 hoch, mit [ObjectUploader](https://docs.aws.amazon.com/aws-sdk-php/v3/api/class-Aws.S3.ObjectUploader.html).
+ Erstellen Sie einen mehrteiligen Upload für ein Amazon S3 S3-Objekt mit [MultipartUploader](https://docs.aws.amazon.com/aws-sdk-php/v3/api/class-Aws.S3.MultipartUploader.html).
+ Kopieren Sie Objekte von einem Amazon S3 S3-Standort an einen anderen mithilfe von [ObjectCopier](https://docs.aws.amazon.com/aws-sdk-php/v3/api/class-Aws.S3.ObjectCopier.html).

Der gesamte Beispielcode für AWS SDK für PHP ist [hier verfügbar GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/php/example_code).

## Anmeldeinformationen
<a name="examplecredentials"></a>

Bevor Sie den Beispielcode ausführen, konfigurieren Sie Ihre AWS Anmeldeinformationen wie unter beschrieben[Authentifizierung AWS mit AWS SDK für PHP Version 3](credentials.md). Importieren Sie dann die AWS SDK für PHP, wie unter beschrieben[Installation der AWS SDK für PHP Version 3](getting-started_installation.md).

## Objekt-Uploader
<a name="object-uploader"></a>

Wenn Sie sich nicht sicher sind, ob `PutObject` oder für die Aufgabe am besten geeignet `MultipartUploader` ist, verwenden Sie. `ObjectUploader` `ObjectUploader`lädt je nach Nutzlastgröße eine große Datei mit `PutObject` oder `MultipartUploader` auf Amazon S3 hoch.

```
require 'vendor/autoload.php';

use Aws\Exception\MultipartUploadException;
use Aws\S3\MultipartUploader;
use Aws\S3\ObjectUploader;
use Aws\S3\S3Client;
```

 **Beispiel-Code** 

```
// Create an S3Client.
$s3Client = new S3Client([
    'profile' => 'default',
    'region' => 'us-east-2',
    'version' => '2006-03-01'
]);

$bucket = 'your-bucket';
$key = 'my-file.zip';

// Use a stream instead of a file path.
$source = fopen('/path/to/large/file.zip', 'rb');

$uploader = new ObjectUploader(
    $s3Client,
    $bucket,
    $key,
    $source
);

do {
    try {
        $result = $uploader->upload();
        if ($result["@metadata"]["statusCode"] == '200') {
            print('<p>File successfully uploaded to ' . $result["ObjectURL"] . '.</p>');
        }
        print($result);
        // If the SDK chooses a multipart upload, try again if there is an exception.
        // Unlike PutObject calls, multipart upload calls are not automatically retried.
    } catch (MultipartUploadException $e) {
        rewind($source);
        $uploader = new MultipartUploader($s3Client, $source, [
            'state' => $e->getState(),
        ]);
    }
} while (!isset($result));

fclose($source);
```

### Konfiguration
<a name="object-uploader-configuration"></a>

Der Konstruktor des `ObjectUploader`-Objekts akzeptiert die folgenden Argumente:

**`$client`**  
Das `Aws\ClientInterface`-Objekt für die Ausführung der Übertragungen. Dies sollte eine Instance von `Aws\S3\S3Client` sein.

**`$bucket`**  
(`string`, *erforderlich*) Name des Buckets, in den das Objekt hochgeladen wird.

**`$key`**  
(`string`, *erforderlich*) Schlüssel, der für das hochzuladende Objekt verwendet werden soll.

**`$body`**  
(`mixed`, *erforderlich*) Objektdaten zum Hochladen. Kann eine`StreamInterface`, eine PHP-Stream-Ressource oder eine hochzuladende Datenfolge sein.

**`$acl`**  
(`string`) Zugriffskontrollliste (ACL), die auf das das hochzuladende Objekt gesetzt wird. Standardmäßig werden alle Objekte als privat eingestuft.

**`$options`**  
Ein assoziatives Array mit Konfigurationsoptionen für den mehrteiligen Upload. Die folgenden Konfigurationsoptionen sind gültig:    
**`add_content_md5`**  
(`bool`) Auf true setzen, um die MD5 Prüfsumme für den Upload automatisch zu berechnen.  
**`mup_threshold`**  
(`int`, *Standard*:`int(16777216)`) Die Anzahl der Byte für die Dateigröße. Wenn die Dateigröße diese Grenze überschreitet, wird ein mehrteiliger Upload verwendet.  
**`before_complete`**  
(`callable`) Callback, der vor der `CompleteMultipartUpload`-Operation aufgerufen wird. Der Callback sollte eine Funktionssignatur haben, die der folgenden ähnelt:. `function (Aws\Command $command) {...}` In der [CompleteMultipartUpload API-Referenz](https://docs.aws.amazon.com/aws-sdk-php/v3/api/api-s3-2006-03-01.html#completemultipartupload) finden Sie die Parameter, die Sie dem `CommandInterface` Objekt hinzufügen können.  
**`before_initiate`**  
(`callable`) Callback, der vor der `CreateMultipartUpload`-Operation aufgerufen wird. Der Callback sollte eine Funktionssignatur haben, die der folgenden ähnelt:`function (Aws\Command $command) {...}`. Das SDK ruft diesen Callback auf, wenn die Dateigröße den Wert überschreitet. `mup_threshold` In der [CreateMultipartUpload API-Referenz](https://docs.aws.amazon.com/aws-sdk-php/v3/api/api-s3-2006-03-01.html#createmultipartupload) finden Sie die Parameter, die Sie dem `CommandInterface` Objekt hinzufügen können.  
**`before_upload`**  
(`callable`) Callback, der vor allen `PutObject` `UploadPart` OR-Operationen aufgerufen werden soll. Der Callback sollte eine Funktionssignatur haben, die der folgenden ähnelt:. `function (Aws\Command $command) {...}` Das SDK ruft diesen Callback auf, wenn die Dateigröße kleiner oder gleich dem Wert ist. `mup_threshold` In der [PutObject API-Referenz](https://docs.aws.amazon.com/aws-sdk-php/v3/api/api-s3-2006-03-01.html#putobject) finden Sie die Parameter, die Sie auf die `PutObject` Anfrage anwenden können. Parameter, die für eine `UploadPart` Anfrage gelten, finden Sie in der [UploadPart API-Referenz](https://docs.aws.amazon.com/aws-sdk-php/v3/api/api-s3-2006-03-01.html#uploadpart). Das SDK ignoriert alle Parameter, die für den durch das `CommandInterface` Objekt repräsentierten Vorgang nicht relevant sind.  
**`concurrency`**  
(`int`*Standard*: `int(3)`) Maximale Anzahl der gleichzeitigen `UploadPart`-Operationen, die während des mehrteiligen Upload zulässig sind.  
**`part_size`**  
(`int`*Standard*: `int(5242880)`) Teilegröße in Byte, die bei einem mehrteiligen Upload zu verwenden ist. Der Wert muss zwischen 5 MB und einschließlich 5 GB liegen.  
**`state`**  
(`Aws\Multipart\UploadState`) Ein Objekt, das den Status des mehrteiligen Upload darstellt, und das verwendet wird, um einen vorhergehenden Upload fortzusetzen. Wenn diese Option angegeben wird, werden die `$key` Argumente `$bucket` und und die `part_size` Option ignoriert.  
**`params`**  
Ein assoziatives Array, das Konfigurationsoptionen für jeden Unterbefehl bereitstellt. Beispiel:  

```
new ObjectUploader($bucket, $key, $body, $acl, ['params' => ['CacheControl' => <some_value>])
```

## MultipartUploader
<a name="multipartuploader"></a>

Mehrteilige Uploads sind darauf ausgelegt, die Upload-Leistung für größere Objekte zu verbessern. Sie ermöglichen Ihnen, Objekte in Teilen unabhängig, in jeder beliebigen Reihenfolge und parallel hochzuladen.

Amazon S3 S3-Kunden wird empfohlen, mehrteilige Uploads für Objekte mit mehr als 100 MB zu verwenden.

## MultipartUploader Objekt
<a name="multipartuploader-object"></a>

Das SDK hat ein spezielles `MultipartUploader`-Objekt, das den mehrteiligen Upload vereinfacht.

 **Importe** 

```
require 'vendor/autoload.php';

use Aws\Exception\MultipartUploadException;
use Aws\S3\MultipartUploader;
use Aws\S3\S3Client;
```

 **Beispiel-Code** 

```
$s3Client = new S3Client([
    'profile' => 'default',
    'region' => 'us-west-2',
    'version' => '2006-03-01'
]);

// Use multipart upload
$source = '/path/to/large/file.zip';
$uploader = new MultipartUploader($s3Client, $source, [
    'bucket' => 'your-bucket',
    'key' => 'my-file.zip',
]);

try {
    $result = $uploader->upload();
    echo "Upload complete: {$result['ObjectURL']}\n";
} catch (MultipartUploadException $e) {
    echo $e->getMessage() . "\n";
}
```

Der Uploader erstellt einen Generator von Teiledaten, basierend auf der bereitgestellten Quelle und Konfiguration, und versucht, alle Teile hochzuladen. Wenn einige Teile-Uploads fehlschlagen, lädt der Uploader spätere Teile weiter, bis die gesamten Quelldaten gelesen wurden. Danach versucht der Uploader, die fehlgeschlagenen Teile hochzuladen, oder gibt eine Ausnahme zurück, die Informationen zu den Teilen enthält, die nicht hochgeladen wurden.

## Anpassen eines mehrteiligen Uploads
<a name="customizing-a-multipart-upload"></a>

Sie können benutzerdefinierte Optionen für die vom Multipart-Uploader ausgeführten Operationen `CreateMultipartUpload`, `UploadPart`und `CompleteMultipartUpload` festlegen. Dazu verwenden Sie Callbacks, die seinem Konstruktor übergeben werden.

 **Importe** 

```
require 'vendor/autoload.php';

use Aws\S3\MultipartUploader;
use Aws\S3\S3Client;
```

 **Beispiel-Code** 

```
// Create an S3Client
$s3Client = new S3Client([
    'profile' => 'default',
    'region' => 'us-west-2',
    'version' => '2006-03-01'
]);

// Customizing a multipart upload
$source = '/path/to/large/file.zip';
$uploader = new MultipartUploader($s3Client, $source, [
    'bucket' => 'your-bucket',
    'key' => 'my-file.zip',
    'before_initiate' => function (Command $command) {
        // $command is a CreateMultipartUpload operation
        $command['CacheControl'] = 'max-age=3600';
    },
    'before_upload' => function (Command $command) {
        // $command is an UploadPart operation
        $command['RequestPayer'] = 'requester';
    },
    'before_complete' => function (Command $command) {
        // $command is a CompleteMultipartUpload operation
        $command['RequestPayer'] = 'requester';
    },
]);
```

### Manuelle Speicherbereinigung zwischen Teil-Uploads
<a name="manual-garbage-collection-between-part-uploads"></a>

Wenn Sie bei großen Uploads das Speicherlimit ausreizen, ist die unter Umstände auf zyklische Referenzen zurückzuführen, die vom SDK konfiguriert wurden und noch nicht von der [PHP-Speicherbereinigung](https://www.php.net/manual/en/features.gc.php) gelöscht wurden, als das Speicherlimit erreicht wurde. Manuelles Aufrufen des Bereinigungsalgorithmus zwischen Operationen ermöglicht unter Umständen die Löschung der Zyklen, bevor das Limit erreicht wird. Das folgende Beispiel ruft den Bereinigungsalgorithmus mithilfe eines Callbacks vor jedem Teile-Upload auf. Beachten Sie, dass das Aufrufen der Speicherbereinigung zulasten der Leistung geht und die optimale Nutzung von Ihrem Anwendungsfall und Ihrer Umgebung abhängt.

```
$uploader = new MultipartUploader($client, $source, [
   'bucket' => 'your-bucket',
   'key' => 'your-key',
   'before_upload' => function(\Aws\Command $command) {
      gc_collect_cycles();
   }
]);
```

## Wiederherstellung nach Fehlern
<a name="recovering-from-errors"></a>

Wenn während des mehrteiligen Uploads ein Fehler auftritt, wird eine `MultipartUploadException` aufgeworfen. Diese Ausnahme bietet Zugriff auf das `UploadState`-Objekt, das Informationen über den Fortschritt des mehrteiligen Uploads enthält. Der `UploadState` kann verwendet werden, um einen Upload fortzusetzen, der nicht abgeschlossen werden konnte.

 **Importe** 

```
require 'vendor/autoload.php';

use Aws\Exception\MultipartUploadException;
use Aws\S3\MultipartUploader;
use Aws\S3\S3Client;
```

 **Beispiel-Code** 

```
// Create an S3Client
$s3Client = new S3Client([
    'profile' => 'default',
    'region' => 'us-west-2',
    'version' => '2006-03-01'
]);

$source = '/path/to/large/file.zip';
$uploader = new MultipartUploader($s3Client, $source, [
    'bucket' => 'your-bucket',
    'key' => 'my-file.zip',
]);

//Recover from errors
do {
    try {
        $result = $uploader->upload();
    } catch (MultipartUploadException $e) {
        $uploader = new MultipartUploader($s3Client, $source, [
            'state' => $e->getState(),
        ]);
    }
} while (!isset($result));

//Abort a multipart upload if failed
try {
    $result = $uploader->upload();
} catch (MultipartUploadException $e) {
    // State contains the "Bucket", "Key", and "UploadId"
    $params = $e->getState()->getId();
    $result = $s3Client->abortMultipartUpload($params);
}
```

Das Fortsetzen eines Uploads von einem `UploadState` aus versucht nur, Teile hochzuladen, die noch nicht hochgeladen sind. Das Statusobjekt verfolgt fehlende Teile, auch wenn sie nicht aufeinanderfolgend sind. Der Uploader liest oder durchsucht über die mitgelieferte Quelldatei nach den Bytebereichen, die zu den Teilen gehören, die noch hochgeladen werden müssen.

 `UploadState`-Objekte sind serialisierbar. Sie können also auch in einem anderen Prozess einen Upload fortzusetzen. Sie können das `UploadState`-Objekt auch dann abrufen, wenn Sie keine Ausnahme verarbeiten. Dazu rufen Sie `$uploader->getState()` auf.

**Wichtig**  
Streams, die einem `MultipartUploader` als Quelle übergeben werden, werden vor dem Hochladen nicht automatisch auf den Anfang zurückgesetzt. Wenn Sie einen Stream anstelle eines Dateipfades in einer Schleife wie im vorherigen Beispiel verwenden, setzen Sie die Variable `$source` innerhalb des `catch`-Blocks zurück.

 **Importe** 

```
require 'vendor/autoload.php';

use Aws\Exception\MultipartUploadException;
use Aws\S3\MultipartUploader;
use Aws\S3\S3Client;
```

 **Beispiel-Code** 

```
// Create an S3Client
$s3Client = new S3Client([
    'profile' => 'default',
    'region' => 'us-west-2',
    'version' => '2006-03-01'
]);

//Using stream instead of file path
$source = fopen('/path/to/large/file.zip', 'rb');
$uploader = new MultipartUploader($s3Client, $source, [
    'bucket' => 'your-bucket',
    'key' => 'my-file.zip',
]);

do {
    try {
        $result = $uploader->upload();
    } catch (MultipartUploadException $e) {
        rewind($source);
        $uploader = new MultipartUploader($s3Client, $source, [
            'state' => $e->getState(),
        ]);
    }
} while (!isset($result));
fclose($source);
```

### Abbrechen eines mehrteiligen Uploads
<a name="aborting-a-multipart-upload"></a>

Ein mehrteiliger Upload kann abgebrochen werden, indem die `UploadId` aus dem Objekt `UploadState` abgerufen und an `abortMultipartUpload` übergeben wird.

```
try {
    $result = $uploader->upload();
} catch (MultipartUploadException $e) {
    // State contains the "Bucket", "Key", and "UploadId"
    $params = $e->getState()->getId();
    $result = $s3Client->abortMultipartUpload($params);
}
```

## Asynchrone mehrteilige Uploads
<a name="asynchronous-multipart-uploads"></a>

Der Aufruf von `upload()` des `MultipartUploader` ist eine blockierende Anfrage. Wenn Sie in einem asynchronen Kontext arbeiten, können Sie ein [Versprechen](guide_promises.md) für den mehrteiligen Upload erhalten.

```
require 'vendor/autoload.php';

use Aws\S3\MultipartUploader;
use Aws\S3\S3Client;
```

 **Beispiel-Code** 

```
// Create an S3Client
$s3Client = new S3Client([
    'profile' => 'default',
    'region' => 'us-west-2',
    'version' => '2006-03-01'
]);

$source = '/path/to/large/file.zip';
$uploader = new MultipartUploader($s3Client, $source, [
    'bucket' => 'your-bucket',
    'key' => 'my-file.zip',
]);

$promise = $uploader->promise();
```

### Konfiguration
<a name="asynchronous-multipart-uploads-configuration"></a>

Der Konstruktor des `MultipartUploader`-Objekts akzeptiert die folgenden Argumente:

** `$client` **  
Das `Aws\ClientInterface`-Objekt für die Ausführung der Übertragungen. Dies sollte eine Instance von `Aws\S3\S3Client` sein.

** `$source` **  
Die hochzuladenden Quelldaten. Hierbei kann es sich um einen Pfad oder eine URL (z. B. `/path/to/file.jpg`), einen Ressourcen-Handle (z. B. `fopen('/path/to/file.jpg', 'r)`) oder eine Instance von einem [PSR-7-Stream](https://docs.aws.amazon.com/aws-sdk-php/v3/api/class-Psr.Http.Message.StreamInterface.html) handeln.

** `$config` **  
Ein assoziatives Array mit Konfigurationsoptionen für den mehrteiligen Upload.  
Die folgenden Konfigurationsoptionen sind gültig:    
** `acl` **  
(`string`) Zugriffskontrollliste (ACL), die auf das das hochzuladende Objekt gesetzt wird. Standardmäßig werden alle Objekte als privat eingestuft.  
** `before_complete` **  
(`callable`) Callback, der vor der `CompleteMultipartUpload`-Operation aufgerufen wird. Der Callback sollte eine Funktionssignatur wie `function (Aws\Command $command) {...}` haben.  
** `before_initiate` **  
(`callable`) Callback, der vor der `CreateMultipartUpload`-Operation aufgerufen wird. Der Callback sollte eine Funktionssignatur wie `function (Aws\Command $command) {...}` haben.  
** `before_upload` **  
(`callable`) Callback, der vor allen `UploadPart`-Operation aufgerufen wird. Der Callback sollte eine Funktionssignatur wie `function (Aws\Command $command) {...}` haben.  
** `bucket` **  
(`string`, *erforderlich*) Name des Buckets, in den das Objekt hochgeladen wird.  
** `concurrency` **  
(`int`*Standard*: `int(5)`) Maximale Anzahl der gleichzeitigen `UploadPart`-Operationen, die während des mehrteiligen Upload zulässig sind.  
** `key` **  
(`string`, *erforderlich*) Schlüssel, der für das hochzuladende Objekt verwendet werden soll.  
** `part_size` **  
(`int`*Standard*: `int(5242880)`) Teilegröße in Byte, die bei einem mehrteiligen Upload zu verwenden ist. Diese muss zwischen einschließlich 5 MB und 5 GB liegen.  
** `state` **  
(`Aws\Multipart\UploadState`) Ein Objekt, das den Status des mehrteiligen Upload darstellt, und das verwendet wird, um einen vorhergehenden Upload fortzusetzen. Wenn diese Option angegeben ist, werden die Optionen `bucket`, `key` und `part_size` ignoriert.  
**`add_content_md5`**  
(`boolean`) Auf true setzen, um die MD5 Prüfsumme für den Upload automatisch zu berechnen.  
**`params`**  
Ein assoziatives Array, das Konfigurationsoptionen für jeden Unterbefehl bereitstellt. Beispiel:  

```
new MultipartUploader($client, $source, ['params' => ['CacheControl' => <some_value>]])
```

## Mehrteilige Kopien
<a name="multipart-copies"></a>

Das beinhaltet AWS SDK für PHP auch ein `MultipartCopy` Objekt, das ähnlich wie das verwendet wird`MultipartUploader`, aber für das Kopieren von Objekten mit einer Größe zwischen 5 GB und 5 TB innerhalb von Amazon S3 konzipiert ist.

```
require 'vendor/autoload.php';

use Aws\Exception\MultipartUploadException;
use Aws\S3\MultipartCopy;
use Aws\S3\S3Client;
```

 **Beispiel-Code** 

```
// Create an S3Client
$s3Client = new S3Client([
    'profile' => 'default',
    'region' => 'us-west-2',
    'version' => '2006-03-01'
]);

//Copy objects within S3
$copier = new MultipartCopy($s3Client, '/bucket/key?versionId=foo', [
    'bucket' => 'your-bucket',
    'key' => 'my-file.zip',
]);

try {
    $result = $copier->copy();
    echo "Copy complete: {$result['ObjectURL']}\n";
} catch (MultipartUploadException $e) {
    echo $e->getMessage() . "\n";
}
```