',
],
],
'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";
}
```
# Configuration des compartiments Amazon S3 avec la AWS SDK pour PHP version 3
Le partage des ressources cross-origin (CORS) définit un moyen pour les applications Web clientes chargées dans un domaine particulier d’interagir avec les ressources d’un autre domaine. Grâce à la prise en charge du CORS dans Amazon S3, vous pouvez créer des applications Web riches côté client avec Amazon S3 et autoriser de manière sélective un accès inter-origines à vos ressources Amazon S3.
Pour plus d'informations sur l'utilisation de la configuration CORS avec un compartiment Amazon S3, consultez [Cross-Origin Resource Sharing (CORS](https://docs.aws.amazon.com/AmazonS3/latest/dev/cors.html)).
Les exemples suivants montrent comment :
+ Obtenez la configuration CORS d'un bucket à l'aide [GetBucketCors](https://docs.aws.amazon.com/aws-sdk-php/v3/api/api-s3-2006-03-01.html#getbucketcors)de.
+ Définissez la configuration CORS pour un bucket à l'aide [PutBucketCors](https://docs.aws.amazon.com/aws-sdk-php/v3/api/api-s3-2006-03-01.html#putbucketcors)de.
Tous les exemples de code pour le AWS SDK pour PHP sont [disponibles ici GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/php/example_code).
## Informations d’identification
Avant d'exécuter l'exemple de code, configurez vos AWS informations d'identification, comme décrit dans[Authentification à l' AWS aide de AWS SDK pour PHP la version 3](credentials.md). Importez ensuite le AWS SDK pour PHP, comme décrit dans[Installation de la AWS SDK pour PHP version 3](getting-started_installation.md).
## Obtenez la configuration CORS
Créez un fichier PHP avec le code suivant. Commencez par créer un service client AWS.S3, puis appelez la méthode `getBucketCors` et spécifiez le compartiment dont vous souhaitez définir la configuration CORS.
Le seul paramètre obligatoire est le nom du compartiment sélectionné. Si le compartiment possède actuellement une configuration CORS, cette configuration est renvoyée par Amazon S3 sous forme d'[CORSRules objet](https://docs.aws.amazon.com/aws-sdk-php/v3/api/api-s3-2006-03-01.html#shape-corsrule).
**Importations**
```
require 'vendor/autoload.php';
use Aws\Exception\AwsException;
use Aws\S3\S3Client;
```
**Exemple de 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());
}
```
## Définissez la configuration CORS
Créez un fichier PHP avec le code suivant. Commencez par créer un service client AWS.S3. Appelez ensuite la `putBucketCors` méthode et spécifiez le bucket dont vous souhaitez définir la configuration CORS, puis CORSConfiguration sous forme d'[objet CORSRules JSON](https://docs.aws.amazon.com/aws-sdk-php/v3/api/api-s3-2006-03-01.html#shape-corsrule).
**Importations**
```
require 'vendor/autoload.php';
use Aws\Exception\AwsException;
use Aws\S3\S3Client;
```
**Exemple de 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());
}
```
# Utilisation des téléchargements partitionnés sur Amazon S3 avec AWS SDK pour PHP la version 3
Vous pouvez charger des objets de taille inférieure ou égale à 5 Go à l'aide d'une simple opération `PutObject`. Cependant, les méthodes de chargement partitionné (par exemple, `CreateMultipartUpload`, `UploadPart`, `CompleteMultipartUpload` et `AbortMultipartUpload`) vous permettent de charger des objets dont la taille est comprise entre 5 Mo et 5 To.
L’exemple suivant indique comment :
+ Chargez un objet sur Amazon S3 à l'aide de [ObjectUploader](https://docs.aws.amazon.com/aws-sdk-php/v3/api/class-Aws.S3.ObjectUploader.html).
+ Créez un téléchargement partitionné pour un objet Amazon S3 à l'aide [MultipartUploader](https://docs.aws.amazon.com/aws-sdk-php/v3/api/class-Aws.S3.MultipartUploader.html)de.
+ Copiez des objets d'un emplacement Amazon S3 à un autre en utilisant [ObjectCopier](https://docs.aws.amazon.com/aws-sdk-php/v3/api/class-Aws.S3.ObjectCopier.html).
Tous les exemples de code pour le AWS SDK pour PHP sont [disponibles ici GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/php/example_code).
## Informations d’identification
Avant d'exécuter l'exemple de code, configurez vos AWS informations d'identification, comme décrit dans[Authentification à l' AWS aide de AWS SDK pour PHP la version 3](credentials.md). Importez ensuite le AWS SDK pour PHP, comme décrit dans[Installation de la AWS SDK pour PHP version 3](getting-started_installation.md).
## Uploader des objets
Si vous n'êtes pas sûr de la solution la mieux adaptée à la tâche, utilisez`ObjectUploader`. `PutObject` `MultipartUploader` `ObjectUploader`télécharge un fichier volumineux sur Amazon S3 en utilisant l'un ou l'autre `PutObject` ou `MultipartUploader` en fonction de la taille de la charge utile.
```
require 'vendor/autoload.php';
use Aws\Exception\MultipartUploadException;
use Aws\S3\MultipartUploader;
use Aws\S3\ObjectUploader;
use Aws\S3\S3Client;
```
**Exemple de 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);
```
### Configuration
Le constructeur de l'objet `ObjectUploader` accepte les arguments suivants :
**`$client`**
L'objet `Aws\ClientInterface` à utiliser pour effectuer les transferts. Il doit s'agir d'une instance de `Aws\S3\S3Client`.
**`$bucket`**
(`string`, *obligatoire*) Nom du compartiment vers lequel l’objet est chargé.
**`$key`**
(`string`, *obligatoire*) Clé à utiliser pour l’objet concerné par le chargement.
**`$body`**
(`mixed`, *obligatoire*) Données d'objet à télécharger. Il peut s'agir `StreamInterface` d'une ressource de flux PHP ou d'une chaîne de données à télécharger.
**`$acl`**
(`string`) Liste de contrôle d'accès (ACL) à définir sur l'objet concerné par le chargement. Les objets sont privés par défaut.
**`$options`**
Un tableau associatif d'options de configuration pour le chargement partitionné. Les options de configuration suivantes sont valides :
**`add_content_md5`**
(`bool`) Réglez sur true pour calculer automatiquement la MD5 somme de contrôle pour le téléchargement.
**`mup_threshold`**
(`int`, *par défaut* :`int(16777216)`) Le nombre d'octets correspondant à la taille du fichier. Si la taille du fichier dépasse cette limite, un téléchargement partitionné est utilisé.
**`before_complete`**
(`callable`) Rappel à invoquer avant l'opération `CompleteMultipartUpload`. Le rappel doit avoir une signature de fonction similaire à :`function (Aws\Command $command) {...}`. Consultez la [référence de l'CompleteMultipartUpload API](https://docs.aws.amazon.com/aws-sdk-php/v3/api/api-s3-2006-03-01.html#completemultipartupload) pour connaître les paramètres que vous pouvez ajouter à l'`CommandInterface`objet.
**`before_initiate`**
(`callable`) Rappel à invoquer avant l'opération `CreateMultipartUpload`. Le rappel doit avoir une signature de fonction similaire à :`function (Aws\Command $command) {...}`. Le SDK invoque ce rappel si la taille du fichier dépasse la valeur. `mup_threshold` Consultez la [référence de l'CreateMultipartUpload API](https://docs.aws.amazon.com/aws-sdk-php/v3/api/api-s3-2006-03-01.html#createmultipartupload) pour connaître les paramètres que vous pouvez ajouter à l'`CommandInterface`objet.
**`before_upload`**
(`callable`) Rappel à invoquer avant `PutObject` toute `UploadPart` opération. Le rappel doit avoir une signature de fonction similaire à :`function (Aws\Command $command) {...}`. Le SDK invoque ce rappel si la taille du fichier est inférieure ou égale à la valeur. `mup_threshold` Consultez la [référence de l'PutObject API](https://docs.aws.amazon.com/aws-sdk-php/v3/api/api-s3-2006-03-01.html#putobject) pour connaître les paramètres que vous pouvez appliquer à la `PutObject` demande. Pour les paramètres qui s'appliquent à une `UploadPart` demande, consultez la [référence de l'UploadPart API](https://docs.aws.amazon.com/aws-sdk-php/v3/api/api-s3-2006-03-01.html#uploadpart). Le SDK ignore tout paramètre non applicable à l'opération représentée par l'`CommandInterface`objet.
**`concurrency`**
(`int`, *par défaut* : `int(3)`) Nombre maximal d’opérations `UploadPart` simultanées autorisées pendant le chargement partitionné.
**`part_size`**
(`int`, *par défaut* : `int(5242880)`) Taille de partie, en octets, à utiliser lors d’un chargement partitionné. La valeur doit être comprise entre 5 Mo et 5 Go inclus.
**`state`**
(`Aws\Multipart\UploadState`) Objet représentant l'état du chargement partitionné et utilisé pour reprendre un chargement précédent. Lorsque cette option est fournie, les `$key` arguments `$bucket` et et l'`part_size`option sont ignorés.
**`params`**
Tableau associatif qui fournit des options de configuration pour chaque sous-commande. Par exemple :
```
new ObjectUploader($bucket, $key, $body, $acl, ['params' => ['CacheControl' => ])
```
## MultipartUploader
Les chargements partitionnés sont conçus pour améliorer l'expérience de chargement pour les objets volumineux. Ils vous permettent de charger des parties d'objets indépendamment, dans n'importe quel ordre, et en parallèle.
Les clients Amazon S3 sont invités à utiliser les téléchargements partitionnés pour les objets de plus de 100 Mo.
## MultipartUploader objet
Le kit SDK dispose d'un objet `MultipartUploader` spécial qui simplifie le processus de chargement partitionné.
**Importations**
```
require 'vendor/autoload.php';
use Aws\Exception\MultipartUploadException;
use Aws\S3\MultipartUploader;
use Aws\S3\S3Client;
```
**Exemple de 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";
}
```
Le chargeur crée un générateur de données partitionnées, en fonction de la source et de la configuration fournies, et tente de charger toutes les parties. Si le chargement de certaines parties échoue, le chargeur continue le chargement des autres parties jusqu'à ce que l'ensemble des données source soient lues. Par la suite, le chargeur tente de charger les parties ayant échoué ou lève une exception contenant des informations sur ces dernières.
## Personnalisation d'un téléchargement en plusieurs parties
Vous pouvez définir des options personnalisées sur les opérations `CreateMultipartUpload`, `UploadPart` et `CompleteMultipartUpload` exécutées par le programme de chargement partitionné via des rappels transmis à son constructeur.
**Importations**
```
require 'vendor/autoload.php';
use Aws\S3\MultipartUploader;
use Aws\S3\S3Client;
```
**Exemple de 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';
},
]);
```
### Collecte manuelle des déchets entre les chargements partiels
Si vous atteignez la limite de mémoire lors de chargements volumineux, c'est peut-être parce que des références cycliques générées par le kit SDK n'ont pas encore été traitées par le [nettoyage de mémoire de PHP](https://www.php.net/manual/en/features.gc.php). L'appel manuel de l'algorithme de nettoyage entre les opérations peut permettre le traitement des cycles avant que cette limite ne soit atteinte. L'exemple suivant appelle l'algorithme de nettoyage en utilisant un rappel avant le chargement de chaque partie. Notez que l'appel du nettoyage de mémoire représente un coût en termes de performances, et que l'utilisation optimale dépendra de votre cas d'utilisation et de l'environnement.
```
$uploader = new MultipartUploader($client, $source, [
'bucket' => 'your-bucket',
'key' => 'your-key',
'before_upload' => function(\Aws\Command $command) {
gc_collect_cycles();
}
]);
```
## Récupération après des erreurs
Lorsqu'une erreur se produit au cours du processus de chargement partitionné, une exception `MultipartUploadException` est levée. Cette exception donne accès à l'objet `UploadState`, qui contient des informations sur la progression du chargement partitionné. L'objet `UploadState` peut être utilisé pour reprendre un chargement qui n'a pas pu aboutir.
**Importations**
```
require 'vendor/autoload.php';
use Aws\Exception\MultipartUploadException;
use Aws\S3\MultipartUploader;
use Aws\S3\S3Client;
```
**Exemple de 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);
}
```
Reprendre un chargement à partir d'un objet `UploadState` permet de tenter de charger les parties qui n'ont pas encore été chargées. L'objet d'état assure le suivi des parties manquantes, même si elles ne se suivent pas. Le chargeur lit ou recherche dans le fichier source fourni les plages d'octets appartenant aux parties qui n'ont pas encore été chargées.
Les objets `UploadState` étant sérialisables, vous pouvez également reprendre un chargement dans un processus différent. De plus, vous pouvez récupérer l'objet `UploadState`, même en l'absence d'exception, en appelant la méthode `$uploader->getState()`.
**Important**
Les flux transmis comme source à un `MultipartUploader` ne sont pas automatiquement rembobinés avant le chargement. Si vous utilisez un flux à la place d'un chemin d'accès dans une boucle similaire à celle de l'exemple précédent, réinitialisez la variable `$source` à l'intérieur du bloc `catch`.
**Importations**
```
require 'vendor/autoload.php';
use Aws\Exception\MultipartUploadException;
use Aws\S3\MultipartUploader;
use Aws\S3\S3Client;
```
**Exemple de 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);
```
### Interruption d’un chargement partitionné
Un chargement partitionné peut être interrompu en récupérant le `UploadId` contenu dans l'objet `UploadState` et en le trnasmettant à `abortMultipartUpload`.
```
try {
$result = $uploader->upload();
} catch (MultipartUploadException $e) {
// State contains the "Bucket", "Key", and "UploadId"
$params = $e->getState()->getId();
$result = $s3Client->abortMultipartUpload($params);
}
```
## Chargements partitionnés asynchrones
Appeler `upload()` sur le `MultipartUploader` constitue une demande de blocage. Si vous travaillez dans un contexte asynchrone, vous pouvez obtenir une [promesse](guide_promises.md) pour le chargement partitionné.
```
require 'vendor/autoload.php';
use Aws\S3\MultipartUploader;
use Aws\S3\S3Client;
```
**Exemple de 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();
```
### Configuration
Le constructeur de l'objet `MultipartUploader` accepte les arguments suivants :
** `$client` **
L'objet `Aws\ClientInterface` à utiliser pour effectuer les transferts. Il doit s'agir d'une instance de `Aws\S3\S3Client`.
** `$source` **
Les données source concernées par le chargement. Il peut s'agir d'un chemin d'accès ou d'une URL (par exemple, `/path/to/file.jpg`), d'un gestionnaire de ressources (par exemple, `fopen('/path/to/file.jpg', 'r)`) ou d'une instance d'un [flux PSR-7](https://docs.aws.amazon.com/aws-sdk-php/v3/api/class-Psr.Http.Message.StreamInterface.html).
** `$config` **
Un tableau associatif d'options de configuration pour le chargement partitionné.
Les options de configuration suivantes sont valides :
** `acl` **
(`string`) Liste de contrôle d'accès (ACL) à définir sur l'objet concerné par le chargement. Les objets sont privés par défaut.
** `before_complete` **
(`callable`) Rappel à invoquer avant l'opération `CompleteMultipartUpload`. Les rappels doivent avoir une signature de fonction telle que `function (Aws\Command $command) {...}`.
** `before_initiate` **
(`callable`) Rappel à invoquer avant l'opération `CreateMultipartUpload`. Les rappels doivent avoir une signature de fonction telle que `function (Aws\Command $command) {...}`.
** `before_upload` **
(`callable`) Rappel à invoquer avant toute opération `UploadPart`. Les rappels doivent avoir une signature de fonction telle que `function (Aws\Command $command) {...}`.
** `bucket` **
(`string`, *obligatoire*) Nom du compartiment vers lequel l’objet est chargé.
** `concurrency` **
(`int`, *par défaut* : `int(5)`) Nombre maximal d’opérations `UploadPart` simultanées autorisées pendant le chargement partitionné.
** `key` **
(`string`, *obligatoire*) Clé à utiliser pour l’objet concerné par le chargement.
** `part_size` **
(`int`, *par défaut* : `int(5242880)`) Taille de partie, en octets, à utiliser lors d’un chargement partitionné. Doit être comprise entre 5 Mo et 5 Go (inclus).
** `state` **
(`Aws\Multipart\UploadState`) Objet représentant l'état du chargement partitionné et utilisé pour reprendre un chargement précédent. Lorsque cette option est fournie, les options `bucket`, `key` et `part_size` sont ignorées.
**`add_content_md5`**
(`boolean`) Réglez sur true pour calculer automatiquement la MD5 somme de contrôle pour le téléchargement.
**`params`**
Tableau associatif qui fournit des options de configuration pour chaque sous-commande. Par exemple :
```
new MultipartUploader($client, $source, ['params' => ['CacheControl' => ]])
```
## Copies en plusieurs parties
AWS SDK pour PHP Il inclut également un `MultipartCopy` objet qui est utilisé de la même manière que le`MultipartUploader`, mais qui est conçu pour copier des objets d'une taille comprise entre 5 Go et 5 To dans Amazon S3.
```
require 'vendor/autoload.php';
use Aws\Exception\MultipartUploadException;
use Aws\S3\MultipartCopy;
use Aws\S3\S3Client;
```
**Exemple de 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";
}
```
# URL pré-signée Amazon S3 avec AWS SDK pour PHP version 3
Vous pouvez authentifier certains types de demandes en transférant les informations requises en tant que paramètres de la chaîne de requête au lieu d'utiliser l'en-tête HTTP Authorization. Cela est utile pour permettre à un navigateur tiers d'accéder directement à vos données privées Amazon S3 par un navigateur tiers, sans transmettre la demande par proxy. L'idée est de créer une demande « pré-signée » et de l'encoder sous forme d'URL utilisable par un autre utilisateur. De plus, vous pouvez limiter une demande pré-signée en spécifiant un délai d'expiration.
## Création d'une URL pré-signée pour une requête HTTP GET
L'exemple de code suivant montre comment créer une URL pré-signée pour une requête HTTP GET à l'aide du SDK pour PHP.
```
'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;
```
La [référence d'API pour la `createPresignedRequest`](https://docs.aws.amazon.com/aws-sdk-php/v3/api/class-Aws.S3.S3Client.html#method_createPresignedRequest) méthode fournit plus de détails.
Quelqu'un d'autre peut utiliser la `$presignedUrl` valeur pour récupérer l'objet dans l'heure qui suit. Lorsque la requête HTTP GET est effectuée, par exemple à l'aide d'un navigateur, le service S3 voit que l'appel provient de l'utilisateur qui a créé l'URL signée au préalable.
## Création d'une URL pré-signée pour une requête HTTP PUT
L'exemple de code suivant montre comment créer une URL pré-signée pour une requête HTTP PUT à l'aide du SDK pour PHP.
```
'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();
```
Une autre personne peut désormais utiliser l'URL pré-signée dans une requête HTTP PUT pour télécharger un fichier :
```
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 pré-signé POSTs avec la AWS SDK pour PHP version 3
Tout comme le pré-signé URLs, le pré-signé vous POSTs permet de donner un accès d'écriture à un utilisateur sans lui donner AWS d'informations d'identification. Les formulaires POST pré-signés peuvent être créés à l'aide d'une instance d'[AWSs3 V4. PostObject](https://docs.aws.amazon.com/aws-sdk-php/v3/api/class-Aws.S3.PostObjectV4.html)
Les exemples suivants montrent comment :
+ Obtenez des données pour un formulaire de téléchargement POST d'un objet S3 à l'aide de la version [PostObjectV4](https://docs.aws.amazon.com/aws-sdk-php/v3/api/class-Aws.S3.PostObjectV4.html).
Tous les exemples de code pour le AWS SDK pour PHP sont [disponibles ici GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/php/example_code).
## Informations d’identification
**Note**
`PostObjectV4`ne fonctionne pas avec les informations d'identification provenant de AWS IAM Identity Center.
Avant d'exécuter l'exemple de code, configurez vos AWS informations d'identification, comme décrit dans[Authentification à l' AWS aide de AWS SDK pour PHP la version 3](credentials.md). Importez ensuite le AWS SDK pour PHP, comme décrit dans[Installation de la AWS SDK pour PHP version 3](getting-started_installation.md).
## Création de la PostObject V4
Pour créer une instance `PostObjectV4`, vous devez fournir les informations suivantes :
+ Instance de `Aws\S3\S3Client`
+ Compartiment
+ Tableau associatif des champs de saisie du formulaire
+ ensemble de conditions de politique (voir [Construction des politiques](https://docs.aws.amazon.com/AmazonS3/latest/dev/HTTPPOSTForms.html) dans le guide de l'utilisateur d'Amazon Simple Storage Service)
+ Délai d'expiration de la chaîne pour la stratégie (facultatif, une heure par défaut).
**Importations**
```
require '../vendor/autoload.php';
use Aws\S3\PostObjectV4;
use Aws\S3\S3Client;
```
**Exemple de 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
```
# Utilisation d'un compartiment Amazon S3 en tant qu'hôte Web statique avec AWS SDK pour PHP la version 3
Vous pouvez héberger un site web statique sur Amazon S3. Pour en savoir plus, consultez [Hébergement d'un site Web statique sur Amazon S3](https://docs.aws.amazon.com/AmazonS3/latest/dev/WebsiteHosting.html).
L’exemple suivant indique comment :
+ Obtenez la configuration du site Web pour un bucket à l'aide de [GetBucketWebsite](https://docs.aws.amazon.com/aws-sdk-php/v3/api/api-s3-2006-03-01.html#getbucketwebsite).
+ Définissez la configuration du site Web pour un bucket à l'aide de [PutBucketWebsite](https://docs.aws.amazon.com/aws-sdk-php/v3/api/api-s3-2006-03-01.html#putbucketwebsite).
+ Supprimez la configuration du site Web d'un compartiment à l'aide de [DeleteBucketWebsite](https://docs.aws.amazon.com/aws-sdk-php/v3/api/api-s3-2006-03-01.html#deletebucketwebsite).
Tous les exemples de code pour la AWS SDK pour PHP version 3 sont [disponibles ici GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/php/example_code).
## Informations d’identification
Avant d'exécuter l'exemple de code, configurez vos AWS informations d'identification. Voir [Informations d'identification pour la AWS SDK pour PHP version 3](guide_credentials.md).
## Obtenir, définir et supprimer la configuration du site Web pour un bucket
**Importations**
```
require 'vendor/autoload.php';
use Aws\Exception\AwsException;
use Aws\S3\S3Client;
```
**Exemple de 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";
}
```
# Utilisation des politiques relatives aux compartiments Amazon S3 avec la AWS SDK pour PHP version 3
Vous pouvez utiliser une politique de compartiment pour accorder des autorisations à vos ressources Amazon S3. Pour en savoir plus, consultez [Utilisation de stratégies de compartiment et de stratégies utilisateur](https://docs.aws.amazon.com/AmazonS3/latest/dev/using-iam-policies.html).
L’exemple suivant indique comment :
+ Renvoie la politique pour un compartiment spécifié à l'aide de [GetBucketPolicy](https://docs.aws.amazon.com/aws-sdk-php/v3/api/api-s3-2006-03-01.html#getbucketpolicy).
+ Remplacez une politique sur un bucket à l'aide de [PutBucketPolicy](https://docs.aws.amazon.com/aws-sdk-php/v3/api/api-s3-2006-03-01.html#putbucketpolicy).
+ Supprimez une politique d'un bucket à l'aide de [DeleteBucketPolicy](https://docs.aws.amazon.com/aws-sdk-php/v3/api/api-s3-2006-03-01.html#deletebucketpolicy).
Tous les exemples de code pour le AWS SDK pour PHP sont [disponibles ici GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/php/example_code).
## Informations d’identification
Avant d'exécuter l'exemple de code, configurez vos AWS informations d'identification, comme décrit dans[Authentification à l' AWS aide de AWS SDK pour PHP la version 3](credentials.md). Importez ensuite le AWS SDK pour PHP, comme décrit dans[Installation de la AWS SDK pour PHP version 3](getting-started_installation.md).
## Obtenir, supprimer et remplacer une politique sur un bucket
**Importations**
```
require "vendor/autoload.php";
use Aws\Exception\AwsException;
use Aws\S3\S3Client;
```
**Exemple de 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";
}
```
# Utilisation du point ARNs d'accès S3 ( AWS SDK pour PHP version 3)
S3 a introduit des points d'accès, une nouvelle façon d'interagir avec les compartiments S3. Les points d'accès peuvent avoir des stratégies et une configuration uniques appliquées à eux plutôt que directement au compartiment. Vous AWS SDK pour PHP permet d'utiliser le point d'accès ARNs dans le champ du bucket pour les opérations d'API au lieu de spécifier explicitement le nom du bucket. Vous trouverez plus de détails sur le fonctionnement et le ARNs fonctionnement des points d'accès S3 [ici](https://docs.aws.amazon.com/AmazonS3/latest/dev/using-access-points.html). Les exemples suivants montrent comment :
+ [GetObject](https://docs.aws.amazon.com/aws-sdk-php/v3/api/api-s3-2006-03-01.html#getobject)À utiliser avec l'ARN d'un point d'accès pour récupérer un objet depuis un bucket.
+ [PutObject](https://docs.aws.amazon.com/aws-sdk-php/v3/api/api-s3-2006-03-01.html#putobject)À utiliser avec l'ARN d'un point d'accès pour ajouter un objet à un bucket.
+ Configurez le client S3 pour qu'il utilise la région ARN au lieu de la région client.
Tous les exemples de code pour le AWS SDK pour PHP sont [disponibles ici GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/php/example_code).
## Informations d’identification
Avant d'exécuter l'exemple de code, configurez vos AWS informations d'identification, comme décrit dans[Authentification à l' AWS aide de AWS SDK pour PHP la version 3](credentials.md). Importez ensuite le AWS SDK pour PHP, comme décrit dans[Installation de la AWS SDK pour PHP version 3](getting-started_installation.md).
**Importations**
```
require 'vendor/autoload.php';
use Aws\S3\S3Client;
```
## Obtenir un objet
Créez d'abord un service client AWS.S3 qui spécifie la AWS région et la version. Ensuite, appelez la méthode `getObject` avec votre clé et un ARN de point d'accès S3 dans le champ `Bucket`, qui récupère l'objet du compartiment associé à ce point d'accès.
**Exemple de 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'
]);
```
## Placer un objet dans un seau
Créez d'abord un service client AWS.S3 qui spécifie la AWS région et la version. Ensuite, appelez la méthode `putObject` avec la clé, le corps ou le fichier source souhaité(e), et un ARN de point d'accès S3 dans le champ `Bucket`, ce qui placera l'objet dans le compartiment associé à ce point d'accès.
**Exemple de 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'
]);
```
## Configurer le client S3 pour qu'il utilise la région ARN au lieu de la région cliente
Lors de l'utilisation d'un ARN de point d'accès S3 dans une opération cliente S3, par défaut, le client s'assure que la région ARN correspond à la région cliente, en lançant une exception si ce n'est pas le cas. Ce comportement peut être modifié pour accepter la région ARN sur la région client en définissant l'option de configuration `use_arn_region` sur `true`. Par défaut, l'option est définie sur `false`.
**Exemple de code**
```
$s3 = new S3Client([
'version' => 'latest',
'region' => 'us-west-2',
'use_arn_region' => true
]);
```
Le client vérifiera également une variable d'environnement et une option de fichier de configuration, dans l'ordre de priorité suivant :
1. L'option client `use_arn_region`, comme dans l'exemple ci-dessus.
1. La variable d'environnement `AWS_S3_USE_ARN_REGION`
```
export AWS_S3_USE_ARN_REGION=true
```
1. La variable de configuration `s3_use_arn_region` dans le fichier de configuration AWS partagé (par défaut dans`~/.aws/config`).
```
[default]
s3_use_arn_region = true
```
# Utilisez les points d'accès multirégionaux Amazon S3 avec la AWS SDK pour PHP version 3
Les points d'[accès multirégionaux Amazon Simple Storage Service (S3)](https://docs.aws.amazon.com//AmazonS3/latest/userguide/MultiRegionAccessPoints.html) fournissent un point de terminaison global pour acheminer le trafic de demandes Amazon S3 entre les deux. Régions AWS
Vous pouvez créer des points d'accès multirégionaux à [l'aide du SDK pour](https://docs.aws.amazon.com//aws-sdk-php/v3/api/api-s3control-2018-08-20.html#createmultiregionaccesspoint) PHP, d' AWS un autre SDK, de la console [S3 ou de la CLI, AWS](https://docs.aws.amazon.com//AmazonS3/latest/userguide/multi-region-access-point-create-examples.html)
**Important**
Pour utiliser des points d'accès multirégionaux avec le SDK pour PHP, l'extension [Common Runtime AWS (CRT) doit être installée AWS dans](guide_crt.md) votre environnement PHP.
Lorsque vous créez un point d'accès multirégional, Amazon S3 génère un Amazon Resource Name (ARN) au format suivant :
`arn:aws:s3::account-id:accesspoint/MultiRegionAccessPoint_alias`
Vous pouvez utiliser l'ARN généré à la place du nom du bucket pour `[getObject()](https://docs.aws.amazon.com/aws-sdk-php/v3/api/api-s3-2006-03-01.html#getobject)` et `[putObject()](https://docs.aws.amazon.com/aws-sdk-php/v3/api/api-s3-2006-03-01.html#putobject)` des méthodes.
```
'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";
```