',
],
],
'Bucket' => $bucket,
];
try {
$resp = $s3Client->putBucketAcl($params);
echo "Succeed in setting bucket ACL.\n";
} catch (AwsException $e) {
// Display error message
echo $e->getMessage();
echo "\n";
}
```
# Konfiguration von Amazon S3 S3-Buckets mit AWS SDK für PHP Version 3
Cross-Origin Resource Sharing (CORS) bestimmt für Client-Webanwendungen, die in einer Domain geladen sind, eine Möglichkeit zur Interaktion mit Ressourcen in einer anderen Domain. Mit der CORS-Unterstützung in Amazon S3 können Sie umfangreiche clientseitige Webanwendungen mit Amazon S3 erstellen und selektiv den ursprungsübergreifenden Zugriff auf Ihre Amazon S3 S3-Ressourcen zulassen.
Weitere Informationen zur Verwendung der CORS-Konfiguration mit einem Amazon S3 S3-Bucket finden Sie unter [Cross-Origin Resource Sharing (CORS](https://docs.aws.amazon.com/AmazonS3/latest/dev/cors.html)).
In den nachstehenden Beispielen wird Folgendes veranschaulicht:
+ Rufen Sie die CORS-Konfiguration für einen Bucket ab mit. [GetBucketCors](https://docs.aws.amazon.com/aws-sdk-php/v3/api/api-s3-2006-03-01.html#getbucketcors)
+ Stellen Sie die CORS-Konfiguration für einen Bucket ein mit. [PutBucketCors](https://docs.aws.amazon.com/aws-sdk-php/v3/api/api-s3-2006-03-01.html#putbucketcors)
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
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).
## Holen Sie sich die CORS-Konfiguration
Erstellen Sie eine PHP-Datei, mit folgendem Code: Zuerst erstellen Sie einen AWS.S3-Client-Service, dann rufen Sie die `getBucketCors`-Methode auf und geben Sie den Bucket an, dessen CORS-Konfiguration Sie abrufen wollen.
Der einzige erforderliche Parameter ist der Name der ausgewählten Buckets. Wenn der Bucket derzeit über eine CORS-Konfiguration verfügt, wird diese Konfiguration von Amazon S3 als [CORSRules Objekt](https://docs.aws.amazon.com/aws-sdk-php/v3/api/api-s3-2006-03-01.html#shape-corsrule) zurückgegeben.
**Importe**
```
require 'vendor/autoload.php';
use Aws\Exception\AwsException;
use Aws\S3\S3Client;
```
**Beispiel-Code**
```
$client = new S3Client([
'profile' => 'default',
'region' => 'us-west-2',
'version' => '2006-03-01'
]);
try {
$result = $client->getBucketCors([
'Bucket' => $bucketName, // REQUIRED
]);
var_dump($result);
} catch (AwsException $e) {
// output error message if fails
error_log($e->getMessage());
}
```
## Stellen Sie die CORS-Konfiguration ein
Erstellen Sie eine PHP-Datei, mit folgendem Code: Zuerst erstellen Sie einen AWS.S3-Client-Service. Rufen Sie dann die `putBucketCors` Methode auf und geben Sie den Bucket an, dessen CORS-Konfiguration festgelegt werden soll, und das CORSConfiguration als [CORSRules JSON-Objekt](https://docs.aws.amazon.com/aws-sdk-php/v3/api/api-s3-2006-03-01.html#shape-corsrule).
**Importe**
```
require 'vendor/autoload.php';
use Aws\Exception\AwsException;
use Aws\S3\S3Client;
```
**Beispiel-Code**
```
$client = new S3Client([
'profile' => 'default',
'region' => 'us-west-2',
'version' => '2006-03-01'
]);
try {
$result = $client->putBucketCors([
'Bucket' => $bucketName, // REQUIRED
'CORSConfiguration' => [ // REQUIRED
'CORSRules' => [ // REQUIRED
[
'AllowedHeaders' => ['Authorization'],
'AllowedMethods' => ['POST', 'GET', 'PUT'], // REQUIRED
'AllowedOrigins' => ['*'], // REQUIRED
'ExposeHeaders' => [],
'MaxAgeSeconds' => 3000
],
],
]
]);
var_dump($result);
} catch (AwsException $e) {
// output error message if fails
error_log($e->getMessage());
}
```
# Mehrteilige Amazon S3 S3-Uploads mit AWS SDK für PHP Version 3 verwenden
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
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
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('File successfully uploaded to ' . $result["ObjectURL"] . '.
');
}
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
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' => ])
```
## MultipartUploader
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
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
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
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
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
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
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
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' => ]])
```
## Mehrteilige Kopien
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";
}
```
# Vorsignierte Amazon S3 S3-URL mit AWS SDK für PHP Version 3
Einige Anfragetypen können Sie authentifizieren, indem Sie die angeforderten Informationen als Abfragezeichenfolgenparameter übergeben, statt den Authentifizierungs-HTTP-Header zu verwenden. Dies ist nützlich, um den direkten Browserzugriff von Drittanbietern auf Ihre privaten Amazon S3 S3-Daten zu ermöglichen, ohne die Anfrage weiterzuleiten. Die Idee ist, eine „vorsignierte“ Anfrage zu erstellen und sie als URL zu codieren, die ein anderer Benutzer verwenden kann. Darüber hinaus können Sie eine vorab signierte Anfrage durch Angabe einer Ablaufzeit begrenzen.
## Erstellen Sie eine vorsignierte URL für eine HTTP-GET-Anfrage
Das folgende Codebeispiel zeigt, wie Sie mithilfe des SDK for PHP eine vorsignierte URL für eine HTTP-GET-Anfrage erstellen.
```
'us-west-2',
]);
// Supply a CommandInterface object and an expires parameter to the `createPresignedRequest` method.
$request = $s3Client->createPresignedRequest(
$s3Client->getCommand('GetObject', [
'Bucket' => 'amzn-s3-demo-bucket',
'Key' => 'demo-key',
]),
'+1 hour'
);
// From the resulting RequestInterface object, you can get the URL.
$presignedUrl = (string) $request->getUri();
echo $presignedUrl;
```
Die [API-Referenz für die `createPresignedRequest`](https://docs.aws.amazon.com/aws-sdk-php/v3/api/class-Aws.S3.S3Client.html#method_createPresignedRequest) Methode enthält weitere Details.
Eine andere Person kann den `$presignedUrl` Wert verwenden, um das Objekt innerhalb der nächsten Stunde abzurufen. Wenn die HTTP-GET-Anfrage gestellt wird, z. B. über einen Browser, hat der S3-Dienst den Eindruck, dass der Anruf von dem Benutzer kommt, der die vorsignierte URL erstellt hat.
## Erstellen Sie eine vorsignierte URL für eine HTTP-PUT-Anfrage
Das folgende Codebeispiel zeigt, wie Sie mithilfe des SDK for PHP eine vorsignierte URL für eine HTTP-PUT-Anfrage erstellen.
```
'us-west-2',
]);
$request = $s3Client->createPresignedRequest(
$s3Client->getCommand('PutObject', [
'Bucket' => 'amzn-s3-demo-bucket',
'Key' => 'demo-key',
]),
'+1 hour'
);
// From the resulting RequestInterface object, you can get the URL.
$presignedUrl = (string) $request->getUri();
```
Jemand anderes kann jetzt die vorsignierte URL in einer HTTP-PUT-Anfrage verwenden, um eine Datei hochzuladen:
```
use GuzzleHttp\Psr7\Request;
use GuzzleHttp\Psr7\Response;
// ...
function uploadWithPresignedUrl($presignedUrl, $filePath, $s3Client): ?Response
{
// Get the HTTP handler from the S3 client.
$handler = $s3Client->getHandlerList()->resolve();
// Create a stream from the file.
$fileStream = new Stream(fopen($filePath, 'r'));
// Create the request.
$request = new Request(
'PUT',
$presignedUrl,
[
'Content-Type' => mime_content_type($filePath),
'Content-Length' => filesize($filePath)
],
$fileStream
);
// Send the request using the handler.
try {
$promise = $handler($request, []);
$response = $promise->wait();
return $response;
} catch (Exception $e) {
echo "Error uploading file: " . $e->getMessage() . "\n";
return null;
}
}
```
# Amazon S3 POSTs mit AWS SDK für PHP Version 3 vorsigniert
Ähnlich wie vorsigniert URLs können Sie mit POSTs vorsignierten Benutzern Schreibzugriff gewähren, ohne ihnen Anmeldeinformationen zu geben. AWS [Vorsignierte POST-Formulare können mit Hilfe einer Instanz von AWSS3 V4 erstellt werden. PostObject](https://docs.aws.amazon.com/aws-sdk-php/v3/api/class-Aws.S3.PostObjectV4.html)
In den nachstehenden Beispielen wird Folgendes veranschaulicht:
+ [Rufen Sie mit V4 Daten für ein POST-Upload-Formular für S3-Objekte ab. PostObject](https://docs.aws.amazon.com/aws-sdk-php/v3/api/class-Aws.S3.PostObjectV4.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
**Anmerkung**
`PostObjectV4`funktioniert nicht mit Anmeldeinformationen, die von stammen AWS IAM Identity Center.
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).
## Erstellen Sie PostObject V4
Um eine Instance von `PostObjectV4` zu erstellen, müssen Sie Folgendes bereitstellen:
+ Instance von`Aws\S3\S3Client`
+ bucket
+ assoziatives Array mit Formular-Eingabefeldern
+ eine Reihe von Versicherungsbedingungen (siehe [Richtlinienkonstruktion](https://docs.aws.amazon.com/AmazonS3/latest/dev/HTTPPOSTForms.html) im Amazon Simple Storage Service-Benutzerhandbuch)
+ Zeichenfolge für die Ablaufzeit für die Richtlinie (optional, standardmäßig eine Stunde).
**Importe**
```
require '../vendor/autoload.php';
use Aws\S3\PostObjectV4;
use Aws\S3\S3Client;
```
**Beispiel-Code**
```
require '../vendor/autoload.php';
use Aws\S3\PostObjectV4;
use Aws\S3\S3Client;
$client = new S3Client([
'profile' => 'default',
'region' => 'us-east-1',
]);
$bucket = 'amzn-s3-demo-bucket10';
$starts_with = 'user/eric/';
$client->listBuckets();
// Set defaults for form input fields.
$formInputs = ['acl' => 'public-read'];
// Construct an array of conditions for policy.
$options = [
['acl' => 'public-read'],
['bucket' => $bucket],
['starts-with', '$key', $starts_with],
];
// Set an expiration time (optional).
$expires = '+2 hours';
$postObject = new PostObjectV4(
$client,
$bucket,
$formInputs,
$options,
$expires
);
// Get attributes for the HTML form, for example, action, method, enctype.
$formAttributes = $postObject->getFormAttributes();
// Get attributes for the HTML form values.
$formInputs = $postObject->getFormInputs();
?>
PHP
```
# Verwenden eines Amazon S3 S3-Buckets als statischen Webhost mit AWS SDK für PHP Version 3
Sie können in Amazon S3 eine statische Website hosten. Weitere Informationen finden Sie unter [Hosten einer statischen Website auf Amazon S3](https://docs.aws.amazon.com/AmazonS3/latest/dev/WebsiteHosting.html).
Das folgende Beispiel zeigt eine Anleitung für:
+ Rufen Sie die Website-Konfiguration für einen Bucket mithilfe von ab [GetBucketWebsite](https://docs.aws.amazon.com/aws-sdk-php/v3/api/api-s3-2006-03-01.html#getbucketwebsite).
+ Stellen Sie die Website-Konfiguration für einen Bucket mithilfe von ein [PutBucketWebsite](https://docs.aws.amazon.com/aws-sdk-php/v3/api/api-s3-2006-03-01.html#putbucketwebsite).
+ Entfernen Sie die Website-Konfiguration aus einem Bucket mit [DeleteBucketWebsite](https://docs.aws.amazon.com/aws-sdk-php/v3/api/api-s3-2006-03-01.html#deletebucketwebsite).
Der gesamte Beispielcode für die AWS SDK für PHP Version 3 ist [hier verfügbar GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/php/example_code).
## Anmeldeinformationen
Bevor Sie den Beispielcode ausführen, konfigurieren Sie Ihre AWS Anmeldeinformationen. Siehe [Anmeldeinformationen für AWS SDK für PHP Version 3.](guide_credentials.md)
## Rufen Sie die Website-Konfiguration für einen Bucket ab, legen Sie sie fest und löschen Sie sie
**Importe**
```
require 'vendor/autoload.php';
use Aws\Exception\AwsException;
use Aws\S3\S3Client;
```
**Beispiel-Code**
```
$s3Client = new S3Client([
'profile' => 'default',
'region' => 'us-west-2',
'version' => '2006-03-01'
]);
// Retrieving the Bucket Website Configuration
$bucket = 'amzn-s3-demo-bucket';
try {
$resp = $s3Client->getBucketWebsite([
'Bucket' => $bucket
]);
echo "Succeed in retrieving website configuration for bucket: " . $bucket . "\n";
} catch (AwsException $e) {
// output error message if fails
echo $e->getMessage();
echo "\n";
}
// Setting a Bucket Website Configuration
$params = [
'Bucket' => $bucket,
'WebsiteConfiguration' => [
'ErrorDocument' => [
'Key' => 'foo',
],
'IndexDocument' => [
'Suffix' => 'bar',
],
]
];
try {
$resp = $s3Client->putBucketWebsite($params);
echo "Succeed in setting bucket website configuration.\n";
} catch (AwsException $e) {
// Display error message
echo $e->getMessage();
echo "\n";
}
// Deleting a Bucket Website Configuration
try {
$resp = $s3Client->deleteBucketWebsite([
'Bucket' => $bucket
]);
echo "Succeed in deleting policy for bucket: " . $bucket . "\n";
} catch (AwsException $e) {
// output error message if fails
echo $e->getMessage();
echo "\n";
}
```
# Arbeiten mit Amazon S3 S3-Bucket-Richtlinien mit der AWS SDK für PHP Version 3
Sie können eine Bucket-Richtlinie verwenden, um Berechtigungen für Ihre Amazon S3 S3-Ressourcen zu erteilen. Weitere Informationen dazu erhalten Sie unter [Verwendung von Bucket-Richtlinien und Benutzerrichtlinien](https://docs.aws.amazon.com/AmazonS3/latest/dev/using-iam-policies.html).
Das folgende Beispiel zeigt eine Anleitung für:
+ Geben Sie die Richtlinie für einen bestimmten Bucket zurück mit [GetBucketPolicy](https://docs.aws.amazon.com/aws-sdk-php/v3/api/api-s3-2006-03-01.html#getbucketpolicy).
+ Ersetzen Sie eine Richtlinie für einen Bucket mit [PutBucketPolicy](https://docs.aws.amazon.com/aws-sdk-php/v3/api/api-s3-2006-03-01.html#putbucketpolicy).
+ Löschen Sie eine Richtlinie aus einem Bucket mithilfe von [DeleteBucketPolicy](https://docs.aws.amazon.com/aws-sdk-php/v3/api/api-s3-2006-03-01.html#deletebucketpolicy).
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
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).
## Rufen Sie eine Richtlinie für einen Bucket ab, löschen Sie sie und ersetzen Sie sie
**Importe**
```
require "vendor/autoload.php";
use Aws\Exception\AwsException;
use Aws\S3\S3Client;
```
**Beispiel-Code**
```
$s3Client = new S3Client([
'profile' => 'default',
'region' => 'us-west-2',
'version' => '2006-03-01'
]);
$bucket = 'amzn-s3-demo-bucket';
// Get the policy of a specific bucket
try {
$resp = $s3Client->getBucketPolicy([
'Bucket' => $bucket
]);
echo "Succeed in receiving bucket policy:\n";
echo $resp->get('Policy');
echo "\n";
} catch (AwsException $e) {
// Display error message
echo $e->getMessage();
echo "\n";
}
// Deletes the policy from the bucket
try {
$resp = $s3Client->deleteBucketPolicy([
'Bucket' => $bucket
]);
echo "Succeed in deleting policy of bucket: " . $bucket . "\n";
} catch (AwsException $e) {
// Display error message
echo $e->getMessage();
echo "\n";
}
// Replaces a policy on the bucket
try {
$resp = $s3Client->putBucketPolicy([
'Bucket' => $bucket,
'Policy' => 'foo policy',
]);
echo "Succeed in put a policy on bucket: " . $bucket . "\n";
} catch (AwsException $e) {
// Display error message
echo $e->getMessage();
echo "\n";
}
```
# Verwenden des S3-Zugriffspunkts ARNs der AWS SDK für PHP Version 3
S3 hat erstmalig Zugriffspunkte verwendet, eine neue Möglichkeit der Interaktion mit S3-Buckets. Auf Zugriffspunkte können eindeutige Richtlinien und Konfigurationen angewendet werden, anstatt dass sie direkt auf den Bucket angewendet werden. Das AWS SDK für PHP ermöglicht es Ihnen, den Access Point ARNs im Bucket-Feld für API-Operationen zu verwenden, anstatt den Bucket-Namen explizit anzugeben. Weitere Informationen darüber, wie S3-Zugangspunkte und ARNs deren Funktionsweise funktionieren, finden Sie [hier](https://docs.aws.amazon.com/AmazonS3/latest/dev/using-access-points.html). In den nachstehenden Beispielen wird Folgendes veranschaulicht:
+ Wird [GetObject](https://docs.aws.amazon.com/aws-sdk-php/v3/api/api-s3-2006-03-01.html#getobject)zusammen mit einem Access Point-ARN verwendet, um ein Objekt aus einem Bucket abzurufen.
+ Wird [PutObject](https://docs.aws.amazon.com/aws-sdk-php/v3/api/api-s3-2006-03-01.html#putobject)zusammen mit einem Access Point-ARN verwendet, um ein Objekt zu einem Bucket hinzuzufügen.
+ Konfigurieren Sie den S3-Client so, dass er die ARN-Region anstelle der Client-Region verwendet.
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
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).
**Importe**
```
require 'vendor/autoload.php';
use Aws\S3\S3Client;
```
## Objekt abrufen
Erstellen Sie zunächst einen AWS.S3-Clientdienst, der die AWS Region und die Version angibt. Rufen Sie dann die `getObject`-Methode mit Ihrem Schlüssel und einem S3-Zugriffspunkt-ARN im Feld `Bucket` auf. Dadurch wird das Objekt aus dem diesem Zugriffspunkt zugeordneten Bucket abgerufen.
**Beispiel-Code**
```
$s3 = new S3Client([
'version' => 'latest',
'region' => 'us-west-2',
]);
$result = $s3->getObject([
'Bucket' => 'arn:aws:s3:us-west-2:123456789012:accesspoint:endpoint-name',
'Key' => 'MyKey'
]);
```
## Legen Sie ein Objekt in einen Bucket
Erstellen Sie zunächst einen AWS.S3-Client-Dienst, der die AWS Region und die Version angibt. Rufen Sie dann die `putObject`-Methode mit dem gewünschten Schlüssel, dem Hauptteil oder der Quelldatei und einem S3-Zugriffspunkt-ARN im Feld `Bucket` auf. Dadurch wird das Objekt im diesem Zugriffspunkt zugeordneten Bucket abgelegt.
**Beispiel-Code**
```
$s3 = new S3Client([
'version' => 'latest',
'region' => 'us-west-2',
]);
$result = $s3->putObject([
'Bucket' => 'arn:aws:s3:us-west-2:123456789012:accesspoint:endpoint-name',
'Key' => 'MyKey',
'Body' => 'MyBody'
]);
```
## Konfigurieren Sie den S3-Client so, dass er die ARN-Region anstelle der Client-Region verwendet.
Wenn Sie einen S3-Zugriffspunkt-ARN in einer S3-Client-Operation verwenden, stellt der Client standardmäßig sicher, dass die ARN-Region mit der Client-Region übereinstimmt. Ist dies nicht der Fall, löst er eine Ausnahme aus. Dieses Verhalten kann geändert werden, um die ARN-Region gegenüber der Client-Region zu bevorzugen, indem Sie für die Konfigurationsoption `use_arn_region` `true` festlegen. Standardmäßig ist für die Option `false` festgelegt.
**Beispiel-Code**
```
$s3 = new S3Client([
'version' => 'latest',
'region' => 'us-west-2',
'use_arn_region' => true
]);
```
Der Client überprüft auch eine Umgebungsvariable und eine Konfigurationsdateioption in der folgenden Reihenfolge der Priorität:
1. Die Client-Option `use_arn_region`, wie im obigen Beispiel
1. Die Umgebungsvariable `AWS_S3_USE_ARN_REGION`
```
export AWS_S3_USE_ARN_REGION=true
```
1. Die Konfigurationsvariable `s3_use_arn_region` in der AWS gemeinsam genutzten Konfigurationsdatei (standardmäßig in`~/.aws/config`).
```
[default]
s3_use_arn_region = true
```
# Verwenden Sie Amazon S3 Multiregion Access Points mit der AWS SDK für PHP Version 3
[Amazon Simple Storage Service (S3) Multi-Region-Access Points](https://docs.aws.amazon.com//AmazonS3/latest/userguide/MultiRegionAccessPoints.html) bieten einen globalen Endpunkt für die Weiterleitung von Amazon S3 S3-Anforderungsdatenverkehr zwischen AWS-Regionen diesen.
Sie können Multi-Region-Access Points [mit dem SDK for PHP](https://docs.aws.amazon.com//aws-sdk-php/v3/api/api-s3control-2018-08-20.html#createmultiregionaccesspoint), einem anderen AWS SDK, der [S3-Konsole oder der AWS CLI](https://docs.aws.amazon.com//AmazonS3/latest/userguide/multi-region-access-point-create-examples.html) erstellen.
**Wichtig**
Um Multi-Region Access Points mit dem SDK for PHP verwenden zu können, muss in Ihrer PHP-Umgebung die [AWS Common Runtime (AWS CRT) -Erweiterung installiert](guide_crt.md) sein.
Wenn Sie einen Access Point mit mehreren Regionen erstellen, generiert Amazon S3 einen Amazon-Ressourcennamen (ARN), der das folgende Format hat:
`arn:aws:s3::account-id:accesspoint/MultiRegionAccessPoint_alias`
Sie können den generierten ARN anstelle eines Bucket-Namens für `[getObject()](https://docs.aws.amazon.com/aws-sdk-php/v3/api/api-s3-2006-03-01.html#getobject)` und `[putObject()](https://docs.aws.amazon.com/aws-sdk-php/v3/api/api-s3-2006-03-01.html#putobject)` Methoden verwenden.
```
'us-east-1'
]);
$s3Client->putObject([
'Bucket' => $mrap,
'Key' => $key,
'Body' => 'Hello World!'
]);
$result = $s3Client->getObject([
'Bucket' => $mrap,
'Key' => $key
]);
echo $result['Body'] . "\n";
// Clean up.
$result = $s3Client->deleteObject([
'Bucket' => $mrap,
'Key' => $key
]);
$s3Client->waitUntil('ObjectNotExists', ['Bucket' => $mrap, 'Key' => $key]);
echo "Object deleted\n";
```