',
],
],
'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";
}
```
# Configurazione dei bucket Amazon S3 con la versione 3 AWS SDK per PHP
La funzionalità CORS (Cross-Origin Resource Sharing, condivisione delle risorse multiorigine) definisce un metodo con cui le applicazioni Web dei clienti caricate in un dominio possono interagire con le risorse situate in un dominio differente. Con il supporto CORS in Amazon S3, puoi creare ricche applicazioni Web lato client con Amazon S3 e consentire selettivamente l'accesso multiorigine alle tue risorse Amazon S3.
Per ulteriori informazioni sull'utilizzo della configurazione CORS con un bucket Amazon S3, [consulta Cross-Origin Resource](https://docs.aws.amazon.com/AmazonS3/latest/dev/cors.html) Sharing (CORS).
Gli esempi seguenti mostrano come:
+ Ottieni la configurazione CORS per un bucket utilizzando. [GetBucketCors](https://docs.aws.amazon.com/aws-sdk-php/v3/api/api-s3-2006-03-01.html#getbucketcors)
+ Imposta la configurazione CORS per un bucket utilizzando. [PutBucketCors](https://docs.aws.amazon.com/aws-sdk-php/v3/api/api-s3-2006-03-01.html#putbucketcors)
Tutto il codice di esempio per AWS SDK per PHP è disponibile [qui](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/php/example_code). GitHub
## Credenziali
Prima di eseguire il codice di esempio, configurate AWS le vostre credenziali, come descritto in[Autenticazione con l' AWS utilizzo AWS SDK per PHP della versione 3](credentials.md). Quindi importate il file AWS SDK per PHP, come descritto in[Installazione della AWS SDK per PHP versione 3](getting-started_installation.md).
## Ottieni la configurazione CORS
Crea un file PHP con il codice seguente. Innanzitutto, crea un servizio client AWS.S3, quindi richiama il metodo `getBucketCors` e specifica il bucket con la configurazione CORS desiderata.
L'unico parametro obbligatorio è il nome del bucket selezionato. [Se il bucket ha attualmente una configurazione CORS, tale configurazione viene restituita da Amazon S3 come oggetto. CORSRules ](https://docs.aws.amazon.com/aws-sdk-php/v3/api/api-s3-2006-03-01.html#shape-corsrule)
**Importazioni**
```
require 'vendor/autoload.php';
use Aws\Exception\AwsException;
use Aws\S3\S3Client;
```
**Codice di esempio**
```
$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());
}
```
## Imposta la configurazione CORS
Crea un file PHP con il codice seguente. Innanzitutto, crea un servizio client AWS.S3. [Quindi chiamate il `putBucketCors` metodo e specificate il bucket di cui impostare la configurazione CORS, quindi CORSConfiguration come oggetto JSON. CORSRules ](https://docs.aws.amazon.com/aws-sdk-php/v3/api/api-s3-2006-03-01.html#shape-corsrule)
**Importazioni**
```
require 'vendor/autoload.php';
use Aws\Exception\AwsException;
use Aws\S3\S3Client;
```
**Codice di esempio**
```
$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());
}
```
# Utilizzo dei caricamenti multiparte di Amazon S3 con la versione 3 AWS SDK per PHP
Con una singola operazione `PutObject`, puoi caricare oggetti di una dimensione massima di 5 GB. Tuttavia, tramite i metodi di caricamento in più parti (ad esempio, `CreateMultipartUpload`, `UploadPart`, `CompleteMultipartUpload`, `AbortMultipartUpload`), puoi caricare oggetti di dimensioni comprese tra 5 MB e 5 TB.
Gli esempi seguenti mostrano come:
+ Carica un oggetto su Amazon S3, utilizzando. [ObjectUploader](https://docs.aws.amazon.com/aws-sdk-php/v3/api/class-Aws.S3.ObjectUploader.html)
+ Crea un caricamento multiparte per un oggetto Amazon S3 utilizzando. [MultipartUploader](https://docs.aws.amazon.com/aws-sdk-php/v3/api/class-Aws.S3.MultipartUploader.html)
+ Copia oggetti da una posizione Amazon S3 a un'altra utilizzando. [ObjectCopier](https://docs.aws.amazon.com/aws-sdk-php/v3/api/class-Aws.S3.ObjectCopier.html)
Tutto il codice di esempio per AWS SDK per PHP è disponibile [qui](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/php/example_code). GitHub
## Credenziali
Prima di eseguire il codice di esempio, configurate AWS le vostre credenziali, come descritto in[Autenticazione con l' AWS utilizzo AWS SDK per PHP della versione 3](credentials.md). Quindi importate il file AWS SDK per PHP, come descritto in[Installazione della AWS SDK per PHP versione 3](getting-started_installation.md).
## Caricatore di oggetti
Se non sei sicuro che sia `PutObject` o `MultipartUploader` meno la soluzione migliore per l'attività, usa. `ObjectUploader` `ObjectUploader`carica un file di grandi dimensioni su Amazon S3 utilizzando `PutObject` `MultipartUploader` o, in base alla dimensione del payload.
```
require 'vendor/autoload.php';
use Aws\Exception\MultipartUploadException;
use Aws\S3\MultipartUploader;
use Aws\S3\ObjectUploader;
use Aws\S3\S3Client;
```
**Codice di esempio**
```
// 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);
```
### Configurazione
Il costruttore dell'oggetto `ObjectUploader` accetta i seguenti argomenti:
**`$client`**
L'oggetto `Aws\ClientInterface` da utilizzare per eseguire i trasferimenti. Deve essere un'istanza di `Aws\S3\S3Client`.
**`$bucket`**
(`string`, *obbligatorio*) Nome del bucket in cui è in corso il caricamento dell'oggetto.
**`$key`**
(`string`, *obbligatorio*) Chiave da utilizzare per l'oggetto in fase di caricamento.
**`$body`**
(`mixed`, *obbligatorio*) Dati dell'oggetto da caricare. Può essere una `StreamInterface` risorsa di flusso PHP o una stringa di dati da caricare.
**`$acl`**
(`string`) Lista di controllo accessi (ACL) da impostare sull'oggetto in fase di caricamento. Gli oggetti sono privati per impostazione predefinita.
**`$options`**
Un array associativo delle opzioni di configurazione del caricamento in più parti. Le seguenti opzioni di configurazione sono valide:
**`add_content_md5`**
(`bool`) Imposta su true per calcolare automaticamente il MD5 checksum per il caricamento.
**`mup_threshold`**
(`int`, *impostazione predefinita*:`int(16777216)`) Il numero di byte per la dimensione del file. Se la dimensione del file supera questo limite, viene utilizzato un caricamento in più parti.
**`before_complete`**
(`callable`) Callback da richiamare prima dell'operazione `CompleteMultipartUpload`. Il callback dovrebbe avere una firma di funzione simile a:. `function (Aws\Command $command) {...}` Consulta il [riferimento CompleteMultipartUpload API](https://docs.aws.amazon.com/aws-sdk-php/v3/api/api-s3-2006-03-01.html#completemultipartupload) per i parametri che puoi aggiungere all'`CommandInterface`oggetto.
**`before_initiate`**
(`callable`) Callback da richiamare prima dell'operazione `CreateMultipartUpload`. Il callback dovrebbe avere una firma di funzione simile a:`function (Aws\Command $command) {...}`. L'SDK richiama questo callback se la dimensione del file supera il valore. `mup_threshold` Consulta il [riferimento all'CreateMultipartUpload API](https://docs.aws.amazon.com/aws-sdk-php/v3/api/api-s3-2006-03-01.html#createmultipartupload) per i parametri che puoi aggiungere all'oggetto. `CommandInterface`
**`before_upload`**
(`callable`) Richiamata da richiamare prima di `PutObject` qualsiasi `UploadPart` operazione. Il callback dovrebbe avere una firma di funzione simile a:. `function (Aws\Command $command) {...}` L'SDK richiama questo callback se la dimensione del file è inferiore o uguale al valore. `mup_threshold` Consulta il [riferimento all'PutObject API](https://docs.aws.amazon.com/aws-sdk-php/v3/api/api-s3-2006-03-01.html#putobject) per i parametri che puoi applicare alla richiesta. `PutObject` Per i parametri che si applicano a una `UploadPart` richiesta, consulta il [riferimento all'UploadPart API](https://docs.aws.amazon.com/aws-sdk-php/v3/api/api-s3-2006-03-01.html#uploadpart). L'SDK ignora qualsiasi parametro non applicabile all'operazione rappresentata dall'`CommandInterface`oggetto.
**`concurrency`**
(`int`, *impostazione predefinita*: `int(3)`) Numero massimo di operazioni `UploadPart` simultanee consentite durante il caricamento in più parti.
**`part_size`**
(`int`, *impostazione predefinita*: `int(5242880)`) Dimensioni, in byte, della parte da utilizzare durante il caricamento in più parti. Il valore deve essere compreso tra 5 MB e 5 GB, inclusi.
**`state`**
(`Aws\Multipart\UploadState`) Un oggetto che rappresenta lo stato del caricamento in più parti e che viene utilizzato per riprendere un caricamento precedente. Quando viene fornita questa opzione, gli `$key` argomenti `$bucket` and e l'`part_size`opzione vengono ignorati.
**`params`**
Un array associativo che fornisce opzioni di configurazione per ogni sottocomando. Esempio:
```
new ObjectUploader($bucket, $key, $body, $acl, ['params' => ['CacheControl' => ])
```
## MultipartUploader
I caricamenti in più parti sono concepiti per migliorare l'esperienza di caricamento degli oggetti di maggiori dimensioni. Consentono di caricare gli oggetti in parti indipendenti, in qualsiasi ordine e in parallelo.
I clienti di Amazon S3 sono incoraggiati a utilizzare caricamenti multiparte per oggetti di dimensioni superiori a 100 MB.
## MultipartUploader oggetto
L'SDK contiene un oggetto `MultipartUploader` speciale che semplifica il processo di caricamento in più parti.
**Importazioni**
```
require 'vendor/autoload.php';
use Aws\Exception\MultipartUploadException;
use Aws\S3\MultipartUploader;
use Aws\S3\S3Client;
```
**Codice di esempio**
```
$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";
}
```
L'uploader crea un generatore di dati della parte, basato sulla sorgente e sulla configurazione specificate, e tenta di caricare tutte le parti. Se il caricamento di alcune parti non riesce, l'uploader continua con il caricamento delle parti successive fino a quando non vengono letti tutti i dati di origine. Successivamente, l'uploader riprova a caricare le parti non riuscite o genera un'eccezione contenente informazioni sulle parti che non è stato possibile caricare.
## Personalizzazione di un caricamento in più parti
Puoi impostare opzioni personalizzate nelle operazioni `CreateMultipartUpload`, `UploadPart` e `CompleteMultipartUpload` eseguite dall'uploader in più parti tramite i callback trasmessi al relativo costruttore.
**Importazioni**
```
require 'vendor/autoload.php';
use Aws\S3\MultipartUploader;
use Aws\S3\S3Client;
```
**Codice di esempio**
```
// 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';
},
]);
```
### Raccolta manuale dei rifiuti tra i caricamenti delle parti
Se caricamenti di grandi dimensioni causano il raggiungimento del limite di memoria, la causa è da ricercarsi nei riferimenti ciclici generati dall'SDK che non sono ancora stati raccolti dal [garbage collector PHP](https://www.php.net/manual/en/features.gc.php) quando il limite di memoria è stato raggiunto. L'invocazione manuale dell'algoritmo di raccolta tra operazioni può consentire la raccolta dei cicli prima del raggiungimento di tale limite. L'esempio seguente richiama l'algoritmo di raccolta utilizzando un callback prima del caricamento di ogni parte. L'invocazione di garbage collector comporta costi di prestazioni e l'uso ottimale dipende dal caso d'uso e dall'ambiente.
```
$uploader = new MultipartUploader($client, $source, [
'bucket' => 'your-bucket',
'key' => 'your-key',
'before_upload' => function(\Aws\Command $command) {
gc_collect_cycles();
}
]);
```
## Recupero da errori
Quando si verifica un errore durante il processo di caricamento in più parti, viene generata una `MultipartUploadException`. Questa eccezione consente l'accesso all'oggetto `UploadState`, contenente le informazioni sull'avanzamento del caricamento in più parti. L'oggetto `UploadState` può essere utilizzato per riprendere un caricamento che non è stato possibile completare.
**Importazioni**
```
require 'vendor/autoload.php';
use Aws\Exception\MultipartUploadException;
use Aws\S3\MultipartUploader;
use Aws\S3\S3Client;
```
**Codice di esempio**
```
// 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);
}
```
La ripresa di un caricamento da un oggetto `UploadState` tenta di caricare le parti che non sono già state caricate. L'oggetto stato tiene traccia delle parti mancanti, anche se non sono consecutive. L'uploader legge o cerca nel file sorgente fornito negli intervalli di byte appartenenti alle parti che devono ancora essere caricate.
Gli oggetti `UploadState` sono serializzabili, quindi puoi riprendere un caricamento anche in un processo diverso. Puoi ottenere inoltre l'oggetto `UploadState`, anche quando non stai gestendo un'eccezione, richiamando `$uploader->getState()`.
**Importante**
I flussi trasmessi come sorgente a `MultipartUploader` non vengono riavvolti automaticamente prima del caricamento. Se utilizzi un flusso al posto di un percorso di file in un loop simile a quello dell'esempio precedente, ripristina la variabile `$source` all'interno del blocco `catch`.
**Importazioni**
```
require 'vendor/autoload.php';
use Aws\Exception\MultipartUploadException;
use Aws\S3\MultipartUploader;
use Aws\S3\S3Client;
```
**Codice di esempio**
```
// 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);
```
### Interruzione di un caricamento in più parti
Un caricamento in più parti può essere interrotto recuperando l'`UploadId` contenuto nell'oggetto `UploadState` e passandolo a `abortMultipartUpload`.
```
try {
$result = $uploader->upload();
} catch (MultipartUploadException $e) {
// State contains the "Bucket", "Key", and "UploadId"
$params = $e->getState()->getId();
$result = $s3Client->abortMultipartUpload($params);
}
```
## Caricamenti asincroni multiparte
La chiamata di `upload()` sul `MultipartUploader` corrisponde a una richiesta di blocco. Se stai lavorando in un contesto asincrono, potresti ricevere una [promessa](guide_promises.md) per il caricamento in più parti.
```
require 'vendor/autoload.php';
use Aws\S3\MultipartUploader;
use Aws\S3\S3Client;
```
**Codice di esempio**
```
// 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();
```
### Configurazione
Il costruttore dell'oggetto `MultipartUploader` accetta i seguenti argomenti:
** `$client` **
L'oggetto `Aws\ClientInterface` da utilizzare per eseguire i trasferimenti. Deve essere un'istanza di `Aws\S3\S3Client`.
** `$source` **
I dati di origine in fase di caricamento. Può essere un percorso o un URL (ad esempio, `/path/to/file.jpg`), un gestore di risorse (ad esempio, `fopen('/path/to/file.jpg', 'r)`) o un'istanza di un [flusso PSR-7](https://docs.aws.amazon.com/aws-sdk-php/v3/api/class-Psr.Http.Message.StreamInterface.html).
** `$config` **
Un array associativo delle opzioni di configurazione del caricamento in più parti.
Le seguenti opzioni di configurazione sono valide:
** `acl` **
(`string`) Lista di controllo accessi (ACL) da impostare sull'oggetto in fase di caricamento. Gli oggetti sono privati per impostazione predefinita.
** `before_complete` **
(`callable`) Callback da richiamare prima dell'operazione `CompleteMultipartUpload`. Il callback deve disporre di una firma della funzione, come `function (Aws\Command $command) {...}`.
** `before_initiate` **
(`callable`) Callback da richiamare prima dell'operazione `CreateMultipartUpload`. Il callback deve disporre di una firma della funzione, come `function (Aws\Command $command) {...}`.
** `before_upload` **
(`callable`) Callback da richiamare prima delle operazioni `UploadPart`. Il callback deve disporre di una firma della funzione, come `function (Aws\Command $command) {...}`.
** `bucket` **
(`string`, *obbligatorio*) Nome del bucket in cui è in corso il caricamento dell'oggetto.
** `concurrency` **
(`int`, *impostazione predefinita*: `int(5)`) Numero massimo di operazioni `UploadPart` simultanee consentite durante il caricamento in più parti.
** `key` **
(`string`, *obbligatorio*) Chiave da utilizzare per l'oggetto in fase di caricamento.
** `part_size` **
(`int`, *impostazione predefinita*: `int(5242880)`) Dimensioni, in byte, della parte da utilizzare durante il caricamento in più parti. Le dimensioni devono essere comprese tra 5 MB e 5 GB, inclusi.
** `state` **
(`Aws\Multipart\UploadState`) Un oggetto che rappresenta lo stato del caricamento in più parti e che viene utilizzato per riprendere un caricamento precedente. Quando questa opzione è disponibile, le opzioni `bucket`, `key` e `part_size` vengono ignorate.
**`add_content_md5`**
(`boolean`) Imposta su true per calcolare automaticamente il checksum per il MD5 caricamento.
**`params`**
Un array associativo che fornisce opzioni di configurazione per ogni sottocomando. Esempio:
```
new MultipartUploader($client, $source, ['params' => ['CacheControl' => ]])
```
## Copie in più parti
Include AWS SDK per PHP anche un `MultipartCopy` oggetto che viene utilizzato in modo simile a`MultipartUploader`, ma è progettato per copiare oggetti di dimensioni comprese tra 5 GB e 5 TB all'interno di Amazon S3.
```
require 'vendor/autoload.php';
use Aws\Exception\MultipartUploadException;
use Aws\S3\MultipartCopy;
use Aws\S3\S3Client;
```
**Codice di esempio**
```
// 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 prefirmato Amazon S3 con versione 3 AWS SDK per PHP
È possibile autenticare alcuni tipi di richieste passando le informazioni necessarie come parametri di una stringa di query invece di utilizzare l'intestazione Autorizzazione HTTP. Ciò è utile per consentire l'accesso diretto tramite browser di terze parti ai dati privati di Amazon S3, senza inoltrare la richiesta tramite proxy. L'idea è quella di creare una richiesta «prefirmata» e codificarla come URL utilizzabile da un altro utente. È inoltre possibile limitare una richiesta prefirmata specificando un periodo di scadenza.
## Crea un URL prefirmato per una richiesta HTTP GET
Il seguente esempio di codice mostra come creare un URL prefirmato per una richiesta HTTP GET utilizzando l'SDK for 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;
```
Il [riferimento all'API per il `createPresignedRequest`](https://docs.aws.amazon.com/aws-sdk-php/v3/api/class-Aws.S3.S3Client.html#method_createPresignedRequest) metodo fornisce ulteriori dettagli.
Qualcun altro può utilizzare il `$presignedUrl` valore per recuperare l'oggetto entro l'ora successiva. Quando viene effettuata la richiesta HTTP GET, ad esempio utilizzando un browser, al servizio S3 sembra che la chiamata provenga dall'utente che ha creato l'URL prefirmato.
## Crea un URL prefirmato per una richiesta HTTP PUT
Il seguente esempio di codice mostra come creare un URL prefirmato per una richiesta HTTP PUT utilizzando l'SDK for 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();
```
Qualcun altro può ora utilizzare l'URL prefirmato in una richiesta HTTP PUT per caricare un file:
```
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 prefirmato POSTs con la versione 3 AWS SDK per PHP
Proprio come quelli prefirmati URLs, i prefirmati POSTs consentono di concedere l'accesso in scrittura a un utente senza fornire loro AWS credenziali. [I moduli POST prefirmati possono essere creati con l'aiuto di un'istanza di AWSS3 V4. PostObject](https://docs.aws.amazon.com/aws-sdk-php/v3/api/class-Aws.S3.PostObjectV4.html)
Gli esempi seguenti mostrano come:
+ [Ottieni i dati per un modulo di caricamento S3 Object POST utilizzando V4. PostObject](https://docs.aws.amazon.com/aws-sdk-php/v3/api/class-Aws.S3.PostObjectV4.html)
Tutto il codice di esempio per il AWS SDK per PHP è disponibile [qui](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/php/example_code). GitHub
## Credenziali
**Nota**
`PostObjectV4`non funziona con credenziali provenienti da. AWS IAM Identity Center
Prima di eseguire il codice di esempio, configurate AWS le vostre credenziali, come descritto in. [Autenticazione con l' AWS utilizzo AWS SDK per PHP della versione 3](credentials.md) Quindi importate il file AWS SDK per PHP, come descritto in[Installazione della AWS SDK per PHP versione 3](getting-started_installation.md).
## Crea PostObject V4
Per creare un'istanza di `PostObjectV4` è necessario fornire quanto segue:
+ istanza di `Aws\S3\S3Client`
+ bucket
+ array associativo dei campi di input del modulo
+ serie di condizioni delle politiche (vedi [Policy Construction](https://docs.aws.amazon.com/AmazonS3/latest/dev/HTTPPOSTForms.html) nella Guida per l'utente di Amazon Simple Storage Service)
+ stringa relativa al periodo di scadenza per la policy (opzionale, il valore predefinito è un'ora).
**Importazioni**
```
require '../vendor/autoload.php';
use Aws\S3\PostObjectV4;
use Aws\S3\S3Client;
```
**Codice di esempio**
```
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
```
# Utilizzo di un bucket Amazon S3 come host Web statico con la versione 3 AWS SDK per PHP
È possibile ospitare un sito Web statico su Amazon S3. Per ulteriori informazioni, consulta [Hosting di un sito Web statico su Amazon S3](https://docs.aws.amazon.com/AmazonS3/latest/dev/WebsiteHosting.html).
Gli esempi seguenti mostrano come:
+ Ottieni la configurazione del sito Web per un bucket utilizzando. [GetBucketWebsite](https://docs.aws.amazon.com/aws-sdk-php/v3/api/api-s3-2006-03-01.html#getbucketwebsite)
+ Imposta la configurazione del sito Web per un bucket utilizzando. [PutBucketWebsite](https://docs.aws.amazon.com/aws-sdk-php/v3/api/api-s3-2006-03-01.html#putbucketwebsite)
+ Rimuovi la configurazione del sito Web da un bucket utilizzando. [DeleteBucketWebsite](https://docs.aws.amazon.com/aws-sdk-php/v3/api/api-s3-2006-03-01.html#deletebucketwebsite)
Tutto il codice di esempio per la AWS SDK per PHP versione 3 è [disponibile GitHub qui](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/php/example_code).
## Credenziali
Prima di eseguire il codice di esempio, configura le tue AWS credenziali. Vedi [Credenziali per la AWS SDK per PHP versione 3](guide_credentials.md).
## Ottieni, imposta ed elimina la configurazione del sito Web per un bucket
**Importazioni**
```
require 'vendor/autoload.php';
use Aws\Exception\AwsException;
use Aws\S3\S3Client;
```
**Codice di esempio**
```
$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";
}
```
# Utilizzo delle policy relative ai bucket di Amazon S3 con la versione 3 AWS SDK per PHP
Puoi utilizzare una bucket policy per concedere l'autorizzazione alle tue risorse Amazon S3. Per ulteriori informazioni, consulta [Utilizzo delle policy per i bucket e delle policy utente](https://docs.aws.amazon.com/AmazonS3/latest/dev/using-iam-policies.html).
Gli esempi seguenti mostrano come:
+ Restituisci la politica per un bucket specificato utilizzando. [GetBucketPolicy](https://docs.aws.amazon.com/aws-sdk-php/v3/api/api-s3-2006-03-01.html#getbucketpolicy)
+ Sostituisci una politica su un bucket utilizzando. [PutBucketPolicy](https://docs.aws.amazon.com/aws-sdk-php/v3/api/api-s3-2006-03-01.html#putbucketpolicy)
+ Elimina una policy da un bucket utilizzando. [DeleteBucketPolicy](https://docs.aws.amazon.com/aws-sdk-php/v3/api/api-s3-2006-03-01.html#deletebucketpolicy)
Tutto il codice di esempio per il AWS SDK per PHP è [disponibile GitHub qui](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/php/example_code).
## Credenziali
Prima di eseguire il codice di esempio, configurate AWS le vostre credenziali, come descritto in[Autenticazione con l' AWS utilizzo AWS SDK per PHP della versione 3](credentials.md). Quindi importate il file AWS SDK per PHP, come descritto in[Installazione della AWS SDK per PHP versione 3](getting-started_installation.md).
## Ottieni, elimina e sostituisci una politica su un bucket
**Importazioni**
```
require "vendor/autoload.php";
use Aws\Exception\AwsException;
use Aws\S3\S3Client;
```
**Codice di esempio**
```
$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";
}
```
# Utilizzo del punto di accesso S3 ( ARNs la AWS SDK per PHP versione 3)
S3 ha introdotto i punti di accesso, un nuovo modo di interagire con i bucket S3. I punti di accesso possono avere criteri e configurazioni univoci applicati ad essi piuttosto che direttamente al bucket. AWS SDK per PHP Consente di utilizzare il punto di accesso ARNs nel campo del bucket per le operazioni API invece di specificare il nome del bucket in modo esplicito. [Maggiori dettagli su come funzionano e ARNs come funzionano i punti di accesso S3 sono disponibili qui.](https://docs.aws.amazon.com/AmazonS3/latest/dev/using-access-points.html) Gli esempi seguenti mostrano come:
+ [GetObject](https://docs.aws.amazon.com/aws-sdk-php/v3/api/api-s3-2006-03-01.html#getobject)Utilizzalo con un punto di accesso ARN per recuperare un oggetto da un bucket.
+ [PutObject](https://docs.aws.amazon.com/aws-sdk-php/v3/api/api-s3-2006-03-01.html#putobject)Utilizzalo con un punto di accesso ARN per aggiungere un oggetto a un bucket.
+ Configurare il client S3 per utilizzare la regione ARN anziché la regione client.
Tutto il codice di esempio per il AWS SDK per PHP è disponibile [qui](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/php/example_code). GitHub
## Credenziali
Prima di eseguire il codice di esempio, configurate AWS le vostre credenziali, come descritto in[Autenticazione con l' AWS utilizzo AWS SDK per PHP della versione 3](credentials.md). Quindi importate il file AWS SDK per PHP, come descritto in[Installazione della AWS SDK per PHP versione 3](getting-started_installation.md).
**Importazioni**
```
require 'vendor/autoload.php';
use Aws\S3\S3Client;
```
## Ottieni oggetto
Per prima cosa crea un servizio client AWS.S3 che specifichi la regione e la AWS versione. Quindi chiama il `getObject` metodo con la tua chiave e un ARN del punto di accesso S3 nel campo `Bucket`, che recupererà l'oggetto dal bucket associato a quel punto di accesso.
**Codice di esempio**
```
$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'
]);
```
## Metti un oggetto in un secchio
Per prima cosa crea un servizio client AWS.S3 che specifichi la regione e la versione. AWS Quindi chiama il metodo `putObject` con la chiave desiderata, il corpo o il file sorgente e un punto di accesso S3 nel campo `Bucket`, che metterà l'oggetto nel bucket associato a quel punto di accesso.
**Codice di esempio**
```
$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'
]);
```
## Configurare il client S3 per utilizzare la regione ARN anziché la regione client
Quando si utilizza un ARN del punto di accesso S3 in un'operazione client S3, per impostazione predefinita il client si assicurerà che la regione ARN corrisponda alla regione client, generando un'eccezione in caso contrario. Questo comportamento può essere modificato per accettare la regione ARN sulla regione client impostando l'opzione di configurazione `use_arn_region` su `true`. Per impostazione predefinita, l'opzione è impostata su `false`.
**Codice di esempio**
```
$s3 = new S3Client([
'version' => 'latest',
'region' => 'us-west-2',
'use_arn_region' => true
]);
```
Il client controllerà anche una variabile d'ambiente e un'opzione del file di configurazione, nel seguente ordine di priorità:
1. L'opzione client `use_arn_region`, come nell'esempio precedente.
1. Nella variabile di ambiente `AWS_S3_USE_ARN_REGION`.
```
export AWS_S3_USE_ARN_REGION=true
```
1. La variabile di configurazione `s3_use_arn_region` nel file di configurazione AWS condiviso (per impostazione predefinita in). `~/.aws/config`
```
[default]
s3_use_arn_region = true
```
# Usa punti di accesso multiregionali Amazon S3 con la versione 3 AWS SDK per PHP
Gli [access point multiregionali di Amazon Simple Storage Service (S3) forniscono un endpoint](https://docs.aws.amazon.com//AmazonS3/latest/userguide/MultiRegionAccessPoints.html) globale per il routing del traffico di richieste Amazon S3 tra di loro. Regioni AWS
Puoi creare punti di accesso multiregionali [utilizzando l'SDK for PHP, AWS un altro SDK](https://docs.aws.amazon.com//aws-sdk-php/v3/api/api-s3control-2018-08-20.html#createmultiregionaccesspoint), la console [S3](https://docs.aws.amazon.com//AmazonS3/latest/userguide/multi-region-access-point-create-examples.html) o la CLI, AWS
**Importante**
Per utilizzare punti di accesso multiregionali con l'SDK for PHP, nell'ambiente PHP deve essere installata l'estensione [Common Runtime AWS (AWS CRT](guide_crt.md)).
Quando crei un punto di accesso multiregionale, Amazon S3 genera un Amazon Resource Name (ARN) con il seguente formato:
`arn:aws:s3::account-id:accesspoint/MultiRegionAccessPoint_alias`
È possibile utilizzare l'ARN generato al posto del nome del bucket per `[getObject()](https://docs.aws.amazon.com/aws-sdk-php/v3/api/api-s3-2006-03-01.html#getobject)` i metodi e. `[putObject()](https://docs.aws.amazon.com/aws-sdk-php/v3/api/api-s3-2006-03-01.html#putobject)`
```
'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";
```