Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.

# Esempi di codice Amazon S3 che utilizzano AWS SDK per C\$1\$1
<a name="examples-s3"></a>

[Amazon S3](https://aws.amazon.com/s3) è uno storage di oggetti progettato per archiviare e recuperare qualsiasi quantità di dati da qualsiasi luogo. Esistono più classi fornite dall'interfaccia AWS SDK per C\$1\$1 to con Amazon S3. 

**Nota**  
In questa guida viene fornito solo il codice necessario per dimostrare determinate tecniche, ma il [codice di esempio completo è disponibile su GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp). GitHub È possibile scaricare un singolo file sorgente oppure clonare il repository localmente per ottenere, compilare ed eseguire tutti gli esempi.
+ Classe [https://docs.aws.amazon.com/sdk-for-cpp/latest/api/aws-cpp-sdk-s3/html/class_aws_1_1_s3_1_1_s3_client.html](https://docs.aws.amazon.com/sdk-for-cpp/latest/api/aws-cpp-sdk-s3/html/class_aws_1_1_s3_1_1_s3_client.html) 

  La `S3Client` libreria è un'interfaccia Amazon S3 completa.

  L'`list_buckets_disabling_dns_cache.cpp`esempio di questo set è progettato specificamente per funzionare con CURL su Linux/Mac (sebbene possa essere modificato per funzionare su Windows). Se utilizzi Windows, elimina il file `list_buckets_disabling_dns_cache.cpp` prima di creare il progetto perché si basa sul HttpClient curl di Linux.

  Il codice di esempio che utilizza `S3Client` si trova nella [`s3`cartella](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code/s3) su Github. Vedi il [Readme](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code/s3/README.md) su Github per un elenco completo delle funzioni dimostrate da questo set di esempi.

  Alcune parti del set di `s3` esempi sono trattate in modo più dettagliato in questa guida:
  + [Creare, elencare ed eliminare i bucket](examples-s3-buckets.md)
  + [Operazioni sugli oggetti](examples-s3-objects.md)— Caricamento e download di oggetti di dati
  + [Gestione delle autorizzazioni di accesso Amazon S3](examples-s3-access-permissions.md)
  + [Gestione dell'accesso ai bucket Amazon S3 utilizzando le policy dei bucket](examples-s3-bucket-policies.md)
  + [Configurazione di un bucket Amazon S3 come sito Web](examples-s3-website-configuration.md)
+ Classe [https://docs.aws.amazon.com/sdk-for-cpp/latest/api/aws-cpp-sdk-s3-crt/html/class_aws_1_1_s3_crt_1_1_s3_crt_client.html](https://docs.aws.amazon.com/sdk-for-cpp/latest/api/aws-cpp-sdk-s3-crt/html/class_aws_1_1_s3_crt_1_1_s3_crt_client.html) 

  `S3CrtClient`È stato aggiunto nella versione 1.9 dell'SDK. `S3CrtClient`fornisce un throughput elevato per le operazioni GET (download) e PUT (upload) di Amazon S3. `S3CrtClient`È implementato nella parte superiore delle librerie AWS Common Runtime (CRT). 

  Il codice di esempio che utilizza `S3CrtClient` si trova nella [`s3-crt`cartella](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code/s3-crt) su Github. Vedi il [Readme](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code/s3-crt/README.md) su Github per un elenco completo delle funzioni dimostrate da questo set di esempi.
  + [Utilizzo `S3CrtClient` per le operazioni di Amazon S3](examples-s3-crt.md)
+ Classe [https://docs.aws.amazon.com/sdk-for-cpp/latest/api/aws-cpp-sdk-transfer/html/class_aws_1_1_transfer_1_1_transfer_manager.html](https://docs.aws.amazon.com/sdk-for-cpp/latest/api/aws-cpp-sdk-transfer/html/class_aws_1_1_transfer_1_1_transfer_manager.html) 

  `TransferManager`è un servizio completamente gestito che consente il trasferimento di file tramite File Transfer Protocol (FTP), File Transfer Protocol over SSL (FTPS) o Secure Shell (SSH) File Transfer Protocol (SFTP) direttamente da e verso Amazon S3.

  [Il codice di esempio che utilizza si trova nella `TransferManager` cartella su Github. `transfer-manager`](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code/transfer-manager) Vedi il [Readme](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code/transfer-manager/README.md) su Github per un elenco completo delle funzioni dimostrate da questo set di esempi.
  + [Utilizzo TransferManager per le operazioni di Amazon S3](examples-s3-transfermanager.md)

# Creare, elencare ed eliminare i bucket
<a name="examples-s3-buckets"></a>

Ogni *oggetto* o file in Amazon Simple Storage Service (Amazon S3) è contenuto in *un bucket, che rappresenta una* cartella di oggetti. Ogni bucket ha al suo interno un nome univoco a livello globale. AWS Per ulteriori informazioni, consulta [Lavorare con i bucket Amazon S3](https://docs.aws.amazon.com/AmazonS3/latest/dev/UsingBucket.html) nella Guida per l'utente di Amazon Simple Storage Service.

## Prerequisiti
<a name="codeExamplePrereq"></a>

Prima di iniziare, ti consigliamo di leggere la [Guida introduttiva all'uso](getting-started.md) di. AWS SDK per C\$1\$1

Scarica il codice di esempio e crea la soluzione come descritto in[Guida introduttiva agli esempi di codice](getting-started-code-examples.md). 

Per eseguire gli esempi, il profilo utente utilizzato dal codice per effettuare le richieste deve disporre delle autorizzazioni appropriate AWS (per il servizio e l'azione). Per ulteriori informazioni, vedere [Fornitura di AWS credenziali](credentials.md).

## Elenco di bucket
<a name="list-buckets"></a>

Per eseguire l'`list_buckets`esempio, al prompt dei comandi, accedi alla cartella in cui il sistema di compilazione crea i file eseguibili della build. Esegui l'eseguibile come `run_list_buckets` segue (il nome del file eseguibile completo sarà diverso in base al sistema operativo). L'output elenca i bucket del tuo account, se ne hai, oppure visualizza un elenco vuoto se non ne hai.

Nel`list_buckets.cpp`, ci sono due metodi.
+ `main()`chiamate`ListBuckets()`. 
+ `ListBuckets()`utilizza l'SDK per interrogare i bucket.

L'`S3Client`oggetto chiama il metodo dell'SDK. `ListBuckets()` In caso di successo, il metodo restituisce un `ListBucketOutcome` oggetto che contiene un `ListBucketResult` oggetto. L'`ListBucketResult`oggetto chiama il `GetBuckets()` metodo per ottenere un elenco di `Bucket` oggetti che contengono informazioni su ogni bucket Amazon S3 nel tuo account.

 **Codice** 

```
bool AwsDoc::S3::listBuckets(const Aws::S3::S3ClientConfiguration &clientConfig) {
    Aws::S3::S3Client client(clientConfig);

    auto outcome = client.ListBuckets();

    bool result = true;
    if (!outcome.IsSuccess()) {
        std::cerr << "Failed with error: " << outcome.GetError() << std::endl;
        result = false;
    } else {
        std::cout << "Found " << outcome.GetResult().GetBuckets().size() << " buckets\n";
        for (auto &&b: outcome.GetResult().GetBuckets()) {
            std::cout << b.GetName() << std::endl;
        }
    }

    return result;
}
```

Guarda l'esempio completo di [list\$1buckets](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code/s3/list_buckets.cpp) su Github.

## Creazione di un bucket
<a name="create-bucket"></a>



Per eseguire l'`create_bucket`esempio, al prompt dei comandi, accedi alla cartella in cui il tuo sistema di compilazione crea i file eseguibili della build. Esegui l'eseguibile come `run_create_bucket` segue (il nome del file eseguibile completo sarà diverso in base al sistema operativo). Il codice crea un bucket vuoto nel tuo account e quindi mostra l'esito positivo o negativo della richiesta.

Nel`create_bucket.cpp`, ci sono due metodi. 
+ `main()`chiamate`CreateBucket()`. Nel`main()`, devi passare Regione AWS alla regione del tuo account utilizzando`enum`. Puoi visualizzare la regione del tuo account accedendo a e individuando la [Console di gestione AWS](https://console.aws.amazon.com/)regione nell'angolo in alto a destra. 
+ `CreateBucket()`utilizza l'SDK per creare un bucket. 



L'`S3Client`oggetto chiama il `CreateBucket()` metodo dell'SDK, passando un `CreateBucketRequest` con il nome del bucket. Per impostazione predefinita, i bucket vengono creati nella regione *us-east-1* (Virginia settentrionale). Se la tua regione non è *us-east-1*, il codice imposta un vincolo bucket per garantire che il bucket venga creato nella tua regione.

 **Codice** 

```
bool AwsDoc::S3::createBucket(const Aws::String &bucketName,
                              const Aws::S3::S3ClientConfiguration &clientConfig) {
    Aws::S3::S3Client client(clientConfig);
    Aws::S3::Model::CreateBucketRequest request;
    request.SetBucket(bucketName);

    if (clientConfig.region != "us-east-1") {
        Aws::S3::Model::CreateBucketConfiguration createBucketConfig;
        createBucketConfig.SetLocationConstraint(
                Aws::S3::Model::BucketLocationConstraintMapper::GetBucketLocationConstraintForName(
                        clientConfig.region));
        request.SetCreateBucketConfiguration(createBucketConfig);
    }

    Aws::S3::Model::CreateBucketOutcome outcome = client.CreateBucket(request);
    if (!outcome.IsSuccess()) {
        auto err = outcome.GetError();
        std::cerr << "Error: createBucket: " <<
                  err.GetExceptionName() << ": " << err.GetMessage() << std::endl;
    } else {
        std::cout << "Created bucket " << bucketName <<
                  " in the specified AWS Region." << std::endl;
    }

    return outcome.IsSuccess();
}
```

[Guarda l'esempio completo di create\$1buckets su Github.](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code/s3/create_bucket.cpp)

## Eliminazione di un bucket
<a name="delete-bucket"></a>



Per eseguire l'`delete_bucket`esempio, al prompt dei comandi, accedi alla cartella in cui il tuo sistema di compilazione crea i file eseguibili della build. Esegui l'eseguibile come `run_delete_bucket` segue (il nome del file eseguibile completo sarà diverso in base al sistema operativo). Il codice elimina il bucket specificato nel tuo account e quindi mostra l'esito positivo o negativo della richiesta.

`delete_bucket.cpp`Esistono due metodi. 
+ `main()`chiamate`DeleteBucket()`. Nel`main()`, devi passare Regione AWS alla regione del tuo account utilizzando`enum`. È inoltre necessario `bucket_name` modificare il nome del bucket da eliminare. 
+ `DeleteBucket()`utilizza l'SDK per eliminare il bucket. 



L'`S3Client`oggetto utilizza il `DeleteBucket()` metodo dell'SDK, passando un `DeleteBucketRequest` oggetto con il nome del bucket da eliminare. Il bucket deve essere vuoto per avere successo.

 **Codice**

```
bool AwsDoc::S3::deleteBucket(const Aws::String &bucketName,
                              const Aws::S3::S3ClientConfiguration &clientConfig) {

    Aws::S3::S3Client client(clientConfig);

    Aws::S3::Model::DeleteBucketRequest request;
    request.SetBucket(bucketName);

    Aws::S3::Model::DeleteBucketOutcome outcome =
            client.DeleteBucket(request);

    if (!outcome.IsSuccess()) {
        const Aws::S3::S3Error &err = outcome.GetError();
        std::cerr << "Error: deleteBucket: " <<
                  err.GetExceptionName() << ": " << err.GetMessage() << std::endl;
    } else {
        std::cout << "The bucket was deleted" << std::endl;
    }

    return outcome.IsSuccess();
}
```

Guarda l'esempio completo di [delete\$1bucket](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code/s3/delete_bucket.cpp) su Github.

# Operazioni sugli oggetti
<a name="examples-s3-objects"></a>

Un oggetto Amazon S3 rappresenta un *file*, che è una raccolta di dati. [Ogni oggetto deve risiedere all'interno di un bucket.](examples-s3-buckets.md)

## Prerequisiti
<a name="codeExamplePrereq"></a>

Prima di iniziare, ti consigliamo di leggere [Guida introduttiva all'utilizzo](getting-started.md) di. AWS SDK per C\$1\$1

Scarica il codice di esempio e crea la soluzione come descritto in[Guida introduttiva agli esempi di codice](getting-started-code-examples.md). 

Per eseguire gli esempi, il profilo utente utilizzato dal codice per effettuare le richieste deve disporre delle autorizzazioni appropriate AWS (per il servizio e l'azione). Per ulteriori informazioni, vedere [Fornitura di AWS credenziali](credentials.md).

## Carica un file in un bucket
<a name="upload-object"></a>

Usa la `PutObject` funzione `S3Client` oggetto, fornendole il nome del bucket, il nome della chiave e il file da caricare. `Aws::FStream`viene utilizzato per caricare il contenuto del file locale nel bucket. Il bucket deve esistere o si verificherà un errore.

Per un esempio sul caricamento asincrono degli oggetti, vedi [Programmazione asincrona mediante AWS SDK per C\$1\$1](async-methods.md)

 **Codice** 

```
bool AwsDoc::S3::putObject(const Aws::String &bucketName,
                           const Aws::String &fileName,
                           const Aws::S3::S3ClientConfiguration &clientConfig) {
    Aws::S3::S3Client s3Client(clientConfig);

    Aws::S3::Model::PutObjectRequest request;
    request.SetBucket(bucketName);
    //We are using the name of the file as the key for the object in the bucket.
    //However, this is just a string and can be set according to your retrieval needs.
    request.SetKey(fileName);

    std::shared_ptr<Aws::IOStream> inputData =
            Aws::MakeShared<Aws::FStream>("SampleAllocationTag",
                                          fileName.c_str(),
                                          std::ios_base::in | std::ios_base::binary);

    if (!*inputData) {
        std::cerr << "Error unable to read file " << fileName << std::endl;
        return false;
    }

    request.SetBody(inputData);

    Aws::S3::Model::PutObjectOutcome outcome =
            s3Client.PutObject(request);

    if (!outcome.IsSuccess()) {
        std::cerr << "Error: putObject: " <<
                  outcome.GetError().GetMessage() << std::endl;
    } else {
        std::cout << "Added object '" << fileName << "' to bucket '"
                  << bucketName << "'.";
    }

    return outcome.IsSuccess();
}
```

Vedi l'[esempio completo](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code/s3/put_object.cpp) su GitHub.

## Carica una stringa in un bucket
<a name="upload-object-string"></a>

Usa la `PutObject` funzione `S3Client` oggetto, fornendole il nome del bucket, il nome della chiave e il file da caricare. Il bucket deve esistere o si verificherà un errore. Questo esempio differisce da quello precedente in quanto viene utilizzato `Aws::StringStream` per caricare un oggetto dati di tipo stringa in memoria direttamente in un bucket.

Per un esempio sul caricamento asincrono di oggetti, vedi [Programmazione asincrona mediante AWS SDK per C\$1\$1](async-methods.md)

 **Codice** 

```
bool AwsDoc::S3::putObjectBuffer(const Aws::String &bucketName,
                                 const Aws::String &objectName,
                                 const std::string &objectContent,
                                 const Aws::S3::S3ClientConfiguration &clientConfig) {
    Aws::S3::S3Client s3Client(clientConfig);

    Aws::S3::Model::PutObjectRequest request;
    request.SetBucket(bucketName);
    request.SetKey(objectName);

    const std::shared_ptr<Aws::IOStream> inputData =
            Aws::MakeShared<Aws::StringStream>("");
    *inputData << objectContent.c_str();

    request.SetBody(inputData);

    Aws::S3::Model::PutObjectOutcome outcome = s3Client.PutObject(request);

    if (!outcome.IsSuccess()) {
        std::cerr << "Error: putObjectBuffer: " <<
                  outcome.GetError().GetMessage() << std::endl;
    } else {
        std::cout << "Success: Object '" << objectName << "' with content '"
                  << objectContent << "' uploaded to bucket '" << bucketName << "'.";
    }

    return outcome.IsSuccess();
}
```

Vedi l'[esempio completo](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code/s3/put_object_buffer.cpp) su GitHub.

## Elenca oggetti
<a name="list-objects"></a>

Per ottenere un elenco di oggetti all'interno di un bucket, utilizzate la funzione object. `S3Client` `ListObjects` Forniscilo con un `ListObjectsRequest` valore che hai impostato con il nome di un bucket di cui elencare il contenuto.

La `ListObjects` funzione restituisce un `ListObjectsOutcome` oggetto che è possibile utilizzare per ottenere un elenco di oggetti sotto forma di `Object` istanze.

 **Codice** 

```
bool AwsDoc::S3::listObjects(const Aws::String &bucketName,
                             Aws::Vector<Aws::String> &keysResult,
                             const Aws::S3::S3ClientConfiguration &clientConfig) {
    Aws::S3::S3Client s3Client(clientConfig);

    Aws::S3::Model::ListObjectsV2Request request;
    request.WithBucket(bucketName);

    Aws::String continuationToken; // Used for pagination.
    Aws::Vector<Aws::S3::Model::Object> allObjects;

    do {
        if (!continuationToken.empty()) {
            request.SetContinuationToken(continuationToken);
        }

        auto outcome = s3Client.ListObjectsV2(request);

        if (!outcome.IsSuccess()) {
            std::cerr << "Error: listObjects: " <<
                      outcome.GetError().GetMessage() << std::endl;
            return false;
        } else {
            Aws::Vector<Aws::S3::Model::Object> objects =
                    outcome.GetResult().GetContents();

            allObjects.insert(allObjects.end(), objects.begin(), objects.end());
            continuationToken = outcome.GetResult().GetNextContinuationToken();
        }
    } while (!continuationToken.empty());

    std::cout << allObjects.size() << " object(s) found:" << std::endl;

    for (const auto &object: allObjects) {
        std::cout << "  " << object.GetKey() << std::endl;
        keysResult.push_back(object.GetKey());
    }

    return true;
}
```

Vedi l'[esempio completo](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code/s3/list_objects.cpp) su GitHub.

## Donwload di un oggetto
<a name="download-object"></a>

Usa la `GetObject` funzione `S3Client` object, passandole una `GetObjectRequest` che hai impostato con il nome di un bucket e la chiave dell'oggetto da scaricare. `GetObject`restituisce un [https://docs.aws.amazon.com/sdk-for-cpp/latest/api/aws-cpp-sdk-s3/html/namespace_aws_1_1_s3_1_1_model.html#a6e16a7b25e8c7547934968a538a15272](https://docs.aws.amazon.com/sdk-for-cpp/latest/api/aws-cpp-sdk-s3/html/namespace_aws_1_1_s3_1_1_model.html#a6e16a7b25e8c7547934968a538a15272)oggetto composto da a [https://docs.aws.amazon.com/sdk-for-cpp/latest/api/aws-cpp-sdk-s3/html/class_aws_1_1_s3_1_1_model_1_1_get_object_result.html](https://docs.aws.amazon.com/sdk-for-cpp/latest/api/aws-cpp-sdk-s3/html/class_aws_1_1_s3_1_1_model_1_1_get_object_result.html)e a [https://docs.aws.amazon.com/sdk-for-cpp/latest/api/aws-cpp-sdk-s3/html/class_aws_1_1_s3_1_1_s3_error.html](https://docs.aws.amazon.com/sdk-for-cpp/latest/api/aws-cpp-sdk-s3/html/class_aws_1_1_s3_1_1_s3_error.html). `GetObjectResult`può essere usato per accedere ai dati dell'oggetto S3.

L'esempio seguente scarica un oggetto da Amazon S3. Il contenuto dell'oggetto viene memorizzato in una variabile locale e la prima riga del contenuto viene inviata alla console.

 **Codice** 

```
bool AwsDoc::S3::getObject(const Aws::String &objectKey,
                           const Aws::String &fromBucket,
                           const Aws::S3::S3ClientConfiguration &clientConfig) {
    Aws::S3::S3Client client(clientConfig);

    Aws::S3::Model::GetObjectRequest request;
    request.SetBucket(fromBucket);
    request.SetKey(objectKey);

    Aws::S3::Model::GetObjectOutcome outcome =
            client.GetObject(request);

    if (!outcome.IsSuccess()) {
        const Aws::S3::S3Error &err = outcome.GetError();
        std::cerr << "Error: getObject: " <<
                  err.GetExceptionName() << ": " << err.GetMessage() << std::endl;
    } else {
        std::cout << "Successfully retrieved '" << objectKey << "' from '"
                  << fromBucket << "'." << std::endl;
    }

    return outcome.IsSuccess();
}
```

Vedi l'[esempio completo](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code/s3/get_object.cpp) su GitHub.

## Eliminazione di un oggetto
<a name="delete-object"></a>

Usa la `DeleteObject` funzione dell'`S3Client`oggetto, passandogli una funzione `DeleteObjectRequest` che hai impostato con il nome di un bucket e dell'oggetto da scaricare. *Il bucket e la chiave dell'oggetto specificati devono esistere o si verificherà un errore*.

 **Codice** 

```
bool AwsDoc::S3::deleteObject(const Aws::String &objectKey,
                              const Aws::String &fromBucket,
                              const Aws::S3::S3ClientConfiguration &clientConfig) {
    Aws::S3::S3Client client(clientConfig);
    Aws::S3::Model::DeleteObjectRequest request;

    request.WithKey(objectKey)
            .WithBucket(fromBucket);

    Aws::S3::Model::DeleteObjectOutcome outcome =
            client.DeleteObject(request);

    if (!outcome.IsSuccess()) {
        auto err = outcome.GetError();
        std::cerr << "Error: deleteObject: " <<
                  err.GetExceptionName() << ": " << err.GetMessage() << std::endl;
    } else {
        std::cout << "Successfully deleted the object." << std::endl;
    }

    return outcome.IsSuccess();
}
```

Vedi l'[esempio completo](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code/s3/delete_object.cpp) su GitHub.

# Gestione delle autorizzazioni di accesso Amazon S3
<a name="examples-s3-access-permissions"></a>

Le autorizzazioni di accesso per un bucket o un oggetto Amazon S3 sono definite in una lista di controllo degli accessi (ACL). L'ACL specifica il proprietario e un elenco di concessioni. bucket/object Ogni concessione specifica un utente (o beneficiario) e le autorizzazioni dell'utente per accedere al bucket/oggetto, ad esempio l'accesso READ o WRITE.

## Prerequisiti
<a name="codeExamplePrereq"></a>

[Prima di iniziare, ti consigliamo di leggere Guida introduttiva all'utilizzo di. AWS SDK per C\$1\$1](getting-started.md) 

Scarica il codice di esempio e crea la soluzione come descritto in[Guida introduttiva agli esempi di codice](getting-started-code-examples.md). 

Per eseguire gli esempi, il profilo utente utilizzato dal codice per effettuare le richieste deve disporre delle autorizzazioni appropriate AWS (per il servizio e l'azione). Per ulteriori informazioni, vedere [Fornitura di AWS credenziali](credentials.md).

## Gestire l'elenco di controllo degli accessi di un oggetto
<a name="manage-an-object-s-access-control-list"></a>

L'elenco di controllo degli accessi per un oggetto può essere recuperato chiamando il `S3Client` metodo`GetObjectAcl`. Il metodo accetta i nomi dell'oggetto e del relativo bucket. Il valore restituito include gli ACL `Owner` e l'elenco di. `Grants`

```
bool AwsDoc::S3::getObjectAcl(const Aws::String &bucketName,
                              const Aws::String &objectKey,
                              const Aws::S3::S3ClientConfiguration &clientConfig) {
    Aws::S3::S3Client s3Client(clientConfig);

    Aws::S3::Model::GetObjectAclRequest request;
    request.SetBucket(bucketName);
    request.SetKey(objectKey);

    Aws::S3::Model::GetObjectAclOutcome outcome =
            s3Client.GetObjectAcl(request);

    if (!outcome.IsSuccess()) {
        const Aws::S3::S3Error &err = outcome.GetError();
        std::cerr << "Error: getObjectAcl: "
                  << err.GetExceptionName() << ": " << err.GetMessage() << std::endl;
    } else {
        Aws::Vector<Aws::S3::Model::Grant> grants =
                outcome.GetResult().GetGrants();

        for (auto it = grants.begin(); it != grants.end(); it++) {
            std::cout << "For object " << objectKey << ": "
                      << std::endl << std::endl;

            Aws::S3::Model::Grant grant = *it;
            Aws::S3::Model::Grantee grantee = grant.GetGrantee();

            if (grantee.TypeHasBeenSet()) {
                std::cout << "Type:          "
                          << getGranteeTypeString(grantee.GetType()) << std::endl;
            }

            if (grantee.DisplayNameHasBeenSet()) {
                std::cout << "Display name:  "
                          << grantee.GetDisplayName() << std::endl;
            }

            if (grantee.EmailAddressHasBeenSet()) {
                std::cout << "Email address: "
                          << grantee.GetEmailAddress() << std::endl;
            }

            if (grantee.IDHasBeenSet()) {
                std::cout << "ID:            "
                          << grantee.GetID() << std::endl;
            }

            if (grantee.URIHasBeenSet()) {
                std::cout << "URI:           "
                          << grantee.GetURI() << std::endl;
            }

            std::cout << "Permission:    " <<
                      getPermissionString(grant.GetPermission()) <<
                      std::endl << std::endl;
        }
    }

    return outcome.IsSuccess();
}

//! Routine which converts a built-in type enumeration to a human-readable string.
/*!
 \param type: Type enumeration.
 \return String: Human-readable string
*/
Aws::String getGranteeTypeString(const Aws::S3::Model::Type &type) {
    switch (type) {
        case Aws::S3::Model::Type::AmazonCustomerByEmail:
            return "Email address of an AWS account";
        case Aws::S3::Model::Type::CanonicalUser:
            return "Canonical user ID of an AWS account";
        case Aws::S3::Model::Type::Group:
            return "Predefined Amazon S3 group";
        case Aws::S3::Model::Type::NOT_SET:
            return "Not set";
        default:
            return "Type unknown";
    }
}

//! Routine which converts a built-in type enumeration to a human-readable string.
/*!
 \param permission: Permission enumeration.
 \return String: Human-readable string
*/
Aws::String getPermissionString(const Aws::S3::Model::Permission &permission) {
    switch (permission) {
        case Aws::S3::Model::Permission::FULL_CONTROL:
            return "Can read this object's data and its metadata, "
                   "and read/write this object's permissions";
        case Aws::S3::Model::Permission::NOT_SET:
            return "Permission not set";
        case Aws::S3::Model::Permission::READ:
            return "Can read this object's data and its metadata";
        case Aws::S3::Model::Permission::READ_ACP:
            return "Can read this object's permissions";
            // case Aws::S3::Model::Permission::WRITE // Not applicable.
        case Aws::S3::Model::Permission::WRITE_ACP:
            return "Can write this object's permissions";
        default:
            return "Permission unknown";
    }
}
```

L'ACL può essere modificato creando un nuovo ACL o modificando le concessioni specificate nell'ACL corrente. L'ACL aggiornato diventa il nuovo ACL corrente passandolo al metodo. `PutObjectAcl`

Il codice seguente utilizza l'ACL recuperato da `GetObjectAcl` e vi aggiunge una nuova concessione. All'utente o al beneficiario viene concessa l'autorizzazione READ per l'oggetto. L'ACL modificato viene passato a`PutObjectAcl`, rendendolo il nuovo ACL corrente. 

```
bool AwsDoc::S3::putObjectAcl(const Aws::String &bucketName, const Aws::String &objectKey, const Aws::String &ownerID,
                              const Aws::String &granteePermission, const Aws::String &granteeType,
                              const Aws::String &granteeID, const Aws::String &granteeEmailAddress,
                              const Aws::String &granteeURI, const Aws::S3::S3ClientConfiguration &clientConfig) {
    Aws::S3::S3Client s3Client(clientConfig);

    Aws::S3::Model::Owner owner;
    owner.SetID(ownerID);

    Aws::S3::Model::Grantee grantee;
    grantee.SetType(setGranteeType(granteeType));

    if (!granteeEmailAddress.empty()) {
        grantee.SetEmailAddress(granteeEmailAddress);
    }

    if (!granteeID.empty()) {
        grantee.SetID(granteeID);
    }

    if (!granteeURI.empty()) {
        grantee.SetURI(granteeURI);
    }

    Aws::S3::Model::Grant grant;
    grant.SetGrantee(grantee);
    grant.SetPermission(setGranteePermission(granteePermission));

    Aws::Vector<Aws::S3::Model::Grant> grants;
    grants.push_back(grant);

    Aws::S3::Model::AccessControlPolicy acp;
    acp.SetOwner(owner);
    acp.SetGrants(grants);

    Aws::S3::Model::PutObjectAclRequest request;
    request.SetAccessControlPolicy(acp);
    request.SetBucket(bucketName);
    request.SetKey(objectKey);

    Aws::S3::Model::PutObjectAclOutcome outcome =
            s3Client.PutObjectAcl(request);

    if (!outcome.IsSuccess()) {
        auto error = outcome.GetError();
        std::cerr << "Error: putObjectAcl: " << error.GetExceptionName()
                  << " - " << error.GetMessage() << std::endl;
    } else {
        std::cout << "Successfully added an ACL to the object '" << objectKey
                  << "' in the bucket '" << bucketName << "'." << std::endl;
    }

    return outcome.IsSuccess();
}

//! Routine which converts a human-readable string to a built-in type enumeration.
/*!
 \param access: Human readable string.
 \return Permission: Permission enumeration.
*/
Aws::S3::Model::Permission setGranteePermission(const Aws::String &access) {
    if (access == "FULL_CONTROL")
        return Aws::S3::Model::Permission::FULL_CONTROL;
    if (access == "WRITE")
        return Aws::S3::Model::Permission::WRITE;
    if (access == "READ")
        return Aws::S3::Model::Permission::READ;
    if (access == "WRITE_ACP")
        return Aws::S3::Model::Permission::WRITE_ACP;
    if (access == "READ_ACP")
        return Aws::S3::Model::Permission::READ_ACP;
    return Aws::S3::Model::Permission::NOT_SET;
}

//! Routine which converts a human-readable string to a built-in type enumeration.
/*!
 \param type: Human readable string.
 \return Type: Type enumeration.
*/
Aws::S3::Model::Type setGranteeType(const Aws::String &type) {
    if (type == "Amazon customer by email")
        return Aws::S3::Model::Type::AmazonCustomerByEmail;
    if (type == "Canonical user")
        return Aws::S3::Model::Type::CanonicalUser;
    if (type == "Group")
        return Aws::S3::Model::Type::Group;
    return Aws::S3::Model::Type::NOT_SET;
}
```

Vedi l'[esempio completo](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code/s3/get_put_object_acl.cpp) su GitHub.

## Gestisci l'elenco di controllo degli accessi di un Bucket
<a name="manage-a-bucket-s-access-control-list"></a>

Nella maggior parte dei casi, il metodo preferito per impostare le autorizzazioni di accesso di un bucket consiste nel definire una policy relativa al bucket. Tuttavia, i bucket supportano anche gli elenchi di controllo degli accessi per gli utenti che desiderano utilizzarli.

La gestione di una lista di controllo degli accessi per un bucket è identica a quella utilizzata per un oggetto. Il `GetBucketAcl` metodo recupera l'ACL corrente di un bucket e `PutBucketAcl` applica un nuovo ACL al bucket.

Il codice seguente dimostra come ottenere e impostare un ACL del bucket.

```
//! Routine which demonstrates setting the ACL for an S3 bucket.
/*!
  \param bucketName: Name of a bucket.
  \param ownerID: The canonical ID of the bucket owner.
   See https://docs.aws.amazon.com/AmazonS3/latest/userguide/finding-canonical-user-id.html for more information.
  \param granteePermission: The access level to enable for the grantee.
  \param granteeType: The type of grantee.
  \param granteeID: The canonical ID of the grantee.
  \param granteeEmailAddress: The email address associated with the grantee's AWS account.
  \param granteeURI: The URI of a built-in access group.
  \param clientConfig: Aws client configuration.
  \return bool: Function succeeded.
*/

bool AwsDoc::S3::getPutBucketAcl(const Aws::String &bucketName,
                                 const Aws::String &ownerID,
                                 const Aws::String &granteePermission,
                                 const Aws::String &granteeType,
                                 const Aws::String &granteeID,
                                 const Aws::String &granteeEmailAddress,
                                 const Aws::String &granteeURI,
                                 const Aws::S3::S3ClientConfiguration &clientConfig) {
    bool result = ::putBucketAcl(bucketName, ownerID, granteePermission, granteeType,
                                 granteeID,
                                 granteeEmailAddress,
                                 granteeURI,
                                 clientConfig);
    if (result) {
        result = ::getBucketAcl(bucketName, clientConfig);
    }

    return result;
}

//! Routine which demonstrates setting the ACL for an S3 bucket.
/*!
  \param bucketName: Name of from bucket.
  \param ownerID: The canonical ID of the bucket owner.
   See https://docs.aws.amazon.com/AmazonS3/latest/userguide/finding-canonical-user-id.html for more information.
  \param granteePermission: The access level to enable for the grantee.
  \param granteeType: The type of grantee.
  \param granteeID: The canonical ID of the grantee.
  \param granteeEmailAddress: The email address associated with the grantee's AWS account.
  \param granteeURI: The URI of a built-in access group.
  \param clientConfig: Aws client configuration.
  \return bool: Function succeeded.
*/

bool putBucketAcl(const Aws::String &bucketName,
                  const Aws::String &ownerID,
                  const Aws::String &granteePermission,
                  const Aws::String &granteeType,
                  const Aws::String &granteeID,
                  const Aws::String &granteeEmailAddress,
                  const Aws::String &granteeURI,
                  const Aws::S3::S3ClientConfiguration &clientConfig) {
    Aws::S3::S3Client s3Client(clientConfig);

    Aws::S3::Model::Owner owner;
    owner.SetID(ownerID);

    Aws::S3::Model::Grantee grantee;
    grantee.SetType(setGranteeType(granteeType));

    if (!granteeEmailAddress.empty()) {
        grantee.SetEmailAddress(granteeEmailAddress);
    }

    if (!granteeID.empty()) {
        grantee.SetID(granteeID);
    }

    if (!granteeURI.empty()) {
        grantee.SetURI(granteeURI);
    }

    Aws::S3::Model::Grant grant;
    grant.SetGrantee(grantee);
    grant.SetPermission(setGranteePermission(granteePermission));

    Aws::Vector<Aws::S3::Model::Grant> grants;
    grants.push_back(grant);

    Aws::S3::Model::AccessControlPolicy acp;
    acp.SetOwner(owner);
    acp.SetGrants(grants);

    Aws::S3::Model::PutBucketAclRequest request;
    request.SetAccessControlPolicy(acp);
    request.SetBucket(bucketName);

    Aws::S3::Model::PutBucketAclOutcome outcome =
            s3Client.PutBucketAcl(request);

    if (!outcome.IsSuccess()) {
        const Aws::S3::S3Error &error = outcome.GetError();

        std::cerr << "Error: putBucketAcl: " << error.GetExceptionName()
                  << " - " << error.GetMessage() << std::endl;
    } else {
        std::cout << "Successfully added an ACL to the bucket '" << bucketName
                  << "'." << std::endl;
    }

    return outcome.IsSuccess();
}

//! Routine which demonstrates getting the ACL for an S3 bucket.
/*!
  \param bucketName: Name of the s3 bucket.
  \param clientConfig: Aws client configuration.
  \return bool: Function succeeded.
*/
bool getBucketAcl(const Aws::String &bucketName,
                  const Aws::S3::S3ClientConfiguration &clientConfig) {
    Aws::S3::S3Client s3Client(clientConfig);

    Aws::S3::Model::GetBucketAclRequest request;
    request.SetBucket(bucketName);

    Aws::S3::Model::GetBucketAclOutcome outcome =
            s3Client.GetBucketAcl(request);

    if (!outcome.IsSuccess()) {
        const Aws::S3::S3Error &err = outcome.GetError();
        std::cerr << "Error: getBucketAcl: "
                  << err.GetExceptionName() << ": " << err.GetMessage() << std::endl;
    } else {
        const Aws::Vector<Aws::S3::Model::Grant> &grants =
                outcome.GetResult().GetGrants();

        for (const Aws::S3::Model::Grant &grant: grants) {
            const Aws::S3::Model::Grantee &grantee = grant.GetGrantee();

            std::cout << "For bucket " << bucketName << ": "
                      << std::endl << std::endl;

            if (grantee.TypeHasBeenSet()) {
                std::cout << "Type:          "
                          << getGranteeTypeString(grantee.GetType()) << std::endl;
            }

            if (grantee.DisplayNameHasBeenSet()) {
                std::cout << "Display name:  "
                          << grantee.GetDisplayName() << std::endl;
            }

            if (grantee.EmailAddressHasBeenSet()) {
                std::cout << "Email address: "
                          << grantee.GetEmailAddress() << std::endl;
            }

            if (grantee.IDHasBeenSet()) {
                std::cout << "ID:            "
                          << grantee.GetID() << std::endl;
            }

            if (grantee.URIHasBeenSet()) {
                std::cout << "URI:           "
                          << grantee.GetURI() << std::endl;
            }

            std::cout << "Permission:    " <<
                      getPermissionString(grant.GetPermission()) <<
                      std::endl << std::endl;
        }
    }

    return outcome.IsSuccess();
}

//! Routine which converts a built-in type enumeration to a human-readable string.
/*!
 \param permission: Permission enumeration.
 \return String: Human-readable string.
*/

Aws::String getPermissionString(const Aws::S3::Model::Permission &permission) {
    switch (permission) {
        case Aws::S3::Model::Permission::FULL_CONTROL:
            return "Can list objects in this bucket, create/overwrite/delete "
                   "objects in this bucket, and read/write this "
                   "bucket's permissions";
        case Aws::S3::Model::Permission::NOT_SET:
            return "Permission not set";
        case Aws::S3::Model::Permission::READ:
            return "Can list objects in this bucket";
        case Aws::S3::Model::Permission::READ_ACP:
            return "Can read this bucket's permissions";
        case Aws::S3::Model::Permission::WRITE:
            return "Can create, overwrite, and delete objects in this bucket";
        case Aws::S3::Model::Permission::WRITE_ACP:
            return "Can write this bucket's permissions";
        default:
            return "Permission unknown";
    }
}

//! Routine which converts a human-readable string to a built-in type enumeration
/*!
 \param access: Human readable string.
 \return Permission: Permission enumeration.
*/
Aws::S3::Model::Permission setGranteePermission(const Aws::String &access) {
    if (access == "FULL_CONTROL")
        return Aws::S3::Model::Permission::FULL_CONTROL;
    if (access == "WRITE")
        return Aws::S3::Model::Permission::WRITE;
    if (access == "READ")
        return Aws::S3::Model::Permission::READ;
    if (access == "WRITE_ACP")
        return Aws::S3::Model::Permission::WRITE_ACP;
    if (access == "READ_ACP")
        return Aws::S3::Model::Permission::READ_ACP;
    return Aws::S3::Model::Permission::NOT_SET;
}

//! Routine which converts a built-in type enumeration to a human-readable string.
/*!
 \param type: Type enumeration.
 \return bool: Human-readable string.
*/
Aws::String getGranteeTypeString(const Aws::S3::Model::Type &type) {
    switch (type) {
        case Aws::S3::Model::Type::AmazonCustomerByEmail:
            return "Email address of an AWS account";
        case Aws::S3::Model::Type::CanonicalUser:
            return "Canonical user ID of an AWS account";
        case Aws::S3::Model::Type::Group:
            return "Predefined Amazon S3 group";
        case Aws::S3::Model::Type::NOT_SET:
            return "Not set";
        default:
            return "Type unknown";
    }
}

Aws::S3::Model::Type setGranteeType(const Aws::String &type) {
    if (type == "Amazon customer by email")
        return Aws::S3::Model::Type::AmazonCustomerByEmail;
    if (type == "Canonical user")
        return Aws::S3::Model::Type::CanonicalUser;
    if (type == "Group")
        return Aws::S3::Model::Type::Group;
    return Aws::S3::Model::Type::NOT_SET;
}
```

Vedi l'[esempio completo](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code/s3/get_put_bucket_acl.cpp) su GitHub.

# Gestione dell'accesso ai bucket Amazon S3 utilizzando le policy dei bucket
<a name="examples-s3-bucket-policies"></a>

Puoi impostare, ottenere o eliminare una *policy sui bucket* per gestire l'accesso ai tuoi bucket Amazon S3.

## Prerequisiti
<a name="codeExamplePrereq"></a>

Prima di iniziare, ti consigliamo di leggere [Guida introduttiva](getting-started.md) all'uso di. AWS SDK per C\$1\$1

Scarica il codice di esempio e crea la soluzione come descritto in[Guida introduttiva agli esempi di codice](getting-started-code-examples.md). 

Per eseguire gli esempi, il profilo utente utilizzato dal codice per effettuare le richieste deve disporre delle autorizzazioni appropriate AWS (per il servizio e l'azione). Per ulteriori informazioni, vedere [Fornitura di AWS credenziali](credentials.md).

## Imposta una policy Bucket
<a name="set-s3-bucket-policy"></a>

Puoi impostare la policy del bucket per un particolare bucket S3 chiamando la `PutBucketPolicy` funzione e `S3Client` fornendole il nome del bucket e la rappresentazione JSON della policy in un. [PutBucketPolicyRequest](https://docs.aws.amazon.com/sdk-for-cpp/latest/api/aws-cpp-sdk-s3/html/class_aws_1_1_s3_1_1_model_1_1_put_bucket_policy_request.html)

 **Codice** 

```
//! Build a policy JSON string.
/*!
  \param userArn: Aws user Amazon Resource Name (ARN).
      For more information, see https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_identifiers.html#identifiers-arns.
  \param bucketName: Name of a bucket.
  \return String: Policy as JSON string.
*/

Aws::String getPolicyString(const Aws::String &userArn,
                            const Aws::String &bucketName) {
    return
            "{\n"
            "   \"Version\":\"2012-10-17\",\n"
            "   \"Statement\":[\n"
            "       {\n"
            "           \"Sid\": \"1\",\n"
            "           \"Effect\": \"Allow\",\n"
            "           \"Principal\": {\n"
            "               \"AWS\": \""
            + userArn +
            "\"\n""           },\n"
            "           \"Action\": [ \"s3:getObject\" ],\n"
            "           \"Resource\": [ \"arn:aws:s3:::"
            + bucketName +
            "/*\" ]\n"
            "       }\n"
            "   ]\n"
            "}";
}
```

```
bool AwsDoc::S3::putBucketPolicy(const Aws::String &bucketName,
                                 const Aws::String &policyBody,
                                 const Aws::S3::S3ClientConfiguration &clientConfig) {
    Aws::S3::S3Client s3Client(clientConfig);

    std::shared_ptr<Aws::StringStream> request_body =
            Aws::MakeShared<Aws::StringStream>("");
    *request_body << policyBody;

    Aws::S3::Model::PutBucketPolicyRequest request;
    request.SetBucket(bucketName);
    request.SetBody(request_body);

    Aws::S3::Model::PutBucketPolicyOutcome outcome =
            s3Client.PutBucketPolicy(request);

    if (!outcome.IsSuccess()) {
        std::cerr << "Error: putBucketPolicy: "
                  << outcome.GetError().GetMessage() << std::endl;
    } else {
        std::cout << "Set the following policy body for the bucket '" <<
                  bucketName << "':" << std::endl << std::endl;
        std::cout << policyBody << std::endl;
    }

    return outcome.IsSuccess();
}
```

**Nota**  
La classe di JsonValue utilità [Aws: :Utils: :Json::](https://docs.aws.amazon.com/sdk-for-cpp/latest/api/aws-cpp-sdk-core/html/class_aws_1_1_utils_1_1_json_1_1_json_value.html) può essere utilizzata per aiutarti a costruire oggetti JSON validi a cui passare. `PutBucketPolicy`

Vedi l'[esempio completo](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code/s3/put_bucket_policy.cpp) su GitHub.

## Ottieni una Bucket Policy
<a name="get-s3-bucket-policy"></a>

Per recuperare la policy per un bucket Amazon S3, chiama `S3Client` la funzione `GetBucketPolicy`'s, passandole il nome del bucket in un. [GetBucketPolicyRequest](https://docs.aws.amazon.com/sdk-for-cpp/latest/api/aws-cpp-sdk-s3/html/class_aws_1_1_s3_1_1_model_1_1_get_bucket_policy_request.html)

 **Codice** 

```
bool AwsDoc::S3::getBucketPolicy(const Aws::String &bucketName,
                                 const Aws::S3::S3ClientConfiguration &clientConfig) {
    Aws::S3::S3Client s3Client(clientConfig);

    Aws::S3::Model::GetBucketPolicyRequest request;
    request.SetBucket(bucketName);

    Aws::S3::Model::GetBucketPolicyOutcome outcome =
            s3Client.GetBucketPolicy(request);

    if (!outcome.IsSuccess()) {
        const Aws::S3::S3Error &err = outcome.GetError();
        std::cerr << "Error: getBucketPolicy: "
                  << err.GetExceptionName() << ": " << err.GetMessage() << std::endl;
    } else {
        Aws::StringStream policy_stream;
        Aws::String line;

        outcome.GetResult().GetPolicy() >> line;
        policy_stream << line;

        std::cout << "Retrieve the policy for bucket '" << bucketName << "':\n\n" <<
                  policy_stream.str() << std::endl;
    }

    return outcome.IsSuccess();
}
```

Vedi l'[esempio completo](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code/s3/get_bucket_policy.cpp) su GitHub.

## Eliminare una policy del bucket
<a name="delete-s3-bucket-policy"></a>

Per eliminare una policy relativa al bucket, chiama la `DeleteBucketPolicy` funzione `S3Client`'s, fornendole il nome del bucket in un. [DeleteBucketPolicyRequest](https://docs.aws.amazon.com/sdk-for-cpp/latest/api/aws-cpp-sdk-s3/html/class_aws_1_1_s3_1_1_model_1_1_delete_bucket_policy_request.html)

 **Codice** 

```
bool AwsDoc::S3::deleteBucketPolicy(const Aws::String &bucketName,
                                    const Aws::S3::S3ClientConfiguration &clientConfig) {
    Aws::S3::S3Client client(clientConfig);

    Aws::S3::Model::DeleteBucketPolicyRequest request;
    request.SetBucket(bucketName);

    Aws::S3::Model::DeleteBucketPolicyOutcome outcome = client.DeleteBucketPolicy(request);

    if (!outcome.IsSuccess()) {
        const Aws::S3::S3Error &err = outcome.GetError();
        std::cerr << "Error: deleteBucketPolicy: " <<
                  err.GetExceptionName() << ": " << err.GetMessage() << std::endl;
    } else {
        std::cout << "Policy was deleted from the bucket." << std::endl;
    }

    return outcome.IsSuccess();
}
```

Questa funzione ha successo anche se il bucket non dispone già di una policy. Se specifichi un nome di bucket che non esiste o se non hai accesso al bucket, viene generato un. `AmazonServiceException`

Vedi l'[esempio completo](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code/s3/delete_bucket_policy.cpp) su GitHub.

## Ulteriori informazioni
<a name="more-info"></a>
+  [PutBucketPolicy](https://docs.aws.amazon.com/AmazonS3/latest/API/PutBucketPolicy.html)nel riferimento alle API di Amazon Simple Storage Service
+  [GetBucketPolicy](https://docs.aws.amazon.com/AmazonS3/latest/API/GetBucketPolicy.html)nel riferimento alle API di Amazon Simple Storage Service
+  [DeleteBucketPolicy](https://docs.aws.amazon.com/AmazonS3/latest/API/DeleteBucketPolicy.html)nel riferimento alle API di Amazon Simple Storage Service
+  [Panoramica del linguaggio delle policy di accesso](https://docs.aws.amazon.com/AmazonS3/latest/dev/access-policy-language-overview.html) nella Guida per l'utente di Amazon Simple Storage Service
+  [Esempi di Bucket Policy](https://docs.aws.amazon.com/AmazonS3/latest/dev/example-bucket-policies.html) nella Guida per l'utente di Amazon Simple Storage Service

# Configurazione di un bucket Amazon S3 come sito Web
<a name="examples-s3-website-configuration"></a>

Puoi configurare un bucket Amazon S3 in modo che si comporti come un sito Web. Per fare ciò, è necessario impostare la configurazione del sito Web.

## Prerequisiti
<a name="codeExamplePrereq"></a>

Prima di iniziare, ti consigliamo di leggere [Guida introduttiva a utilizzare il AWS SDK per C\$1\$1](getting-started.md). 

Scarica il codice di esempio e crea la soluzione come descritto in[Guida introduttiva agli esempi di codice](getting-started-code-examples.md). 

Per eseguire gli esempi, il profilo utente utilizzato dal codice per effettuare le richieste deve disporre delle autorizzazioni appropriate AWS (per il servizio e l'azione). Per ulteriori informazioni, vedere [Fornitura di AWS credenziali](credentials.md).

## Imposta la configurazione del sito Web di Bucket
<a name="set-a-bucket-s-website-configuration"></a>

Per impostare la configurazione del sito Web di un bucket Amazon S3, chiama la `PutBucketWebsite` funzione `S3Client` th's con un [PutBucketWebsiteRequest](https://docs.aws.amazon.com/sdk-for-cpp/latest/api/aws-cpp-sdk-s3/html/class_aws_1_1_s3_1_1_model_1_1_put_bucket_website_request.html)oggetto contenente il nome del bucket e la relativa configurazione del sito Web, forniti in un oggetto. [WebsiteConfiguration](https://docs.aws.amazon.com/sdk-for-cpp/latest/api/aws-cpp-sdk-s3/html/class_aws_1_1_s3_1_1_model_1_1_website_configuration.html)

L'impostazione di un documento indice è *obbligatoria*; tutti gli altri parametri sono facoltativi.

 **Codice** 

```
bool AwsDoc::S3::putWebsiteConfig(const Aws::String &bucketName,
                                  const Aws::String &indexPage, const Aws::String &errorPage,
                                  const Aws::S3::S3ClientConfiguration &clientConfig) {
    Aws::S3::S3Client client(clientConfig);

    Aws::S3::Model::IndexDocument indexDocument;
    indexDocument.SetSuffix(indexPage);

    Aws::S3::Model::ErrorDocument errorDocument;
    errorDocument.SetKey(errorPage);

    Aws::S3::Model::WebsiteConfiguration websiteConfiguration;
    websiteConfiguration.SetIndexDocument(indexDocument);
    websiteConfiguration.SetErrorDocument(errorDocument);

    Aws::S3::Model::PutBucketWebsiteRequest request;
    request.SetBucket(bucketName);
    request.SetWebsiteConfiguration(websiteConfiguration);

    Aws::S3::Model::PutBucketWebsiteOutcome outcome =
            client.PutBucketWebsite(request);

    if (!outcome.IsSuccess()) {
        std::cerr << "Error: PutBucketWebsite: "
                  << outcome.GetError().GetMessage() << std::endl;
    } else {
        std::cout << "Success: Set website configuration for bucket '"
                  << bucketName << "'." << std::endl;
    }

    return outcome.IsSuccess();
}
```

**Nota**  
L'impostazione della configurazione di un sito Web non modifica le autorizzazioni di accesso per il bucket. Per rendere visibili i file sul Web, è inoltre necessario impostare una *policy relativa ai bucket* che consenta l'accesso pubblico in lettura ai file contenuti nel bucket. Per ulteriori informazioni, consulta [Gestione dell'accesso ai bucket Amazon S3 tramite le policy dei bucket](examples-s3-bucket-policies.md).

Vedi l'[esempio completo](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code/s3/put_website_config.cpp) su GitHub.

## Ottieni la configurazione del sito Web di Bucket
<a name="get-a-bucket-s-website-configuration"></a>

Per ottenere la configurazione del sito Web di un bucket Amazon S3, chiama la `GetBucketWebsite` funzione `S3Client` th's con una [GetBucketWebsiteRequest](https://docs.aws.amazon.com/sdk-for-cpp/latest/api/aws-cpp-sdk-s3/html/class_aws_1_1_s3_1_1_model_1_1_get_bucket_website_request.html)contenente il nome del bucket per cui recuperare la configurazione.

La configurazione verrà restituita come [GetBucketWebsiteResult](https://docs.aws.amazon.com/sdk-for-cpp/latest/api/aws-cpp-sdk-s3/html/class_aws_1_1_s3_1_1_model_1_1_get_bucket_website_result.html)oggetto all'interno dell'oggetto risultato. Se non esiste una configurazione del sito Web per il bucket, `null` verrà restituita.

 **Codice** 

```
bool AwsDoc::S3::getWebsiteConfig(const Aws::String &bucketName,
                                  const Aws::S3::S3ClientConfiguration &clientConfig) {
    Aws::S3::S3Client s3Client(clientConfig);

    Aws::S3::Model::GetBucketWebsiteRequest request;
    request.SetBucket(bucketName);

    Aws::S3::Model::GetBucketWebsiteOutcome outcome =
            s3Client.GetBucketWebsite(request);

    if (!outcome.IsSuccess()) {
        const Aws::S3::S3Error &err = outcome.GetError();

        std::cerr << "Error: GetBucketWebsite: "
                  << err.GetMessage() << std::endl;
    } else {
        Aws::S3::Model::GetBucketWebsiteResult websiteResult = outcome.GetResult();

        std::cout << "Success: GetBucketWebsite: "
                  << std::endl << std::endl
                  << "For bucket '" << bucketName << "':"
                  << std::endl
                  << "Index page : "
                  << websiteResult.GetIndexDocument().GetSuffix()
                  << std::endl
                  << "Error page: "
                  << websiteResult.GetErrorDocument().GetKey()
                  << std::endl;
    }

    return outcome.IsSuccess();
}
```

Vedi l'[esempio completo](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code/s3/get_website_config.cpp) su GitHub.

## Elimina la configurazione del sito Web di un Bucket
<a name="delete-a-bucket-s-website-configuration"></a>

Per eliminare la configurazione del sito Web di un bucket Amazon S3, chiama la `DeleteBucketWebsite` funzione `S3Client`'s con un [DeleteBucketWebsiteRequest](https://docs.aws.amazon.com/sdk-for-cpp/latest/api/aws-cpp-sdk-s3/html/class_aws_1_1_s3_1_1_model_1_1_delete_bucket_website_request.html): contenente il nome del bucket da cui eliminare la configurazione.

 **Codice** 

```
bool AwsDoc::S3::deleteBucketWebsite(const Aws::String &bucketName,
                                     const Aws::S3::S3ClientConfiguration &clientConfig) {
    Aws::S3::S3Client client(clientConfig);
    Aws::S3::Model::DeleteBucketWebsiteRequest request;
    request.SetBucket(bucketName);

    Aws::S3::Model::DeleteBucketWebsiteOutcome outcome =
            client.DeleteBucketWebsite(request);

    if (!outcome.IsSuccess()) {
        auto err = outcome.GetError();
        std::cerr << "Error: deleteBucketWebsite: " <<
                  err.GetExceptionName() << ": " << err.GetMessage() << std::endl;
    } else {
        std::cout << "Website configuration was removed." << std::endl;
    }

    return outcome.IsSuccess();
}
```

Vedi l'[esempio completo](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code/s3/delete_website_config.cpp) su GitHub.

## Ulteriori informazioni
<a name="more-information"></a>
+  [Sito Web PUT Bucket nella pagina](https://docs.aws.amazon.com/AmazonS3/latest/API/RESTBucketPUTwebsite.html) di riferimento dell'API Amazon Simple Storage Service
+  [Sito Web GET Bucket nella pagina](https://docs.aws.amazon.com/AmazonS3/latest/API/RESTBucketGETwebsite.html) di riferimento dell'API Amazon Simple Storage Service
+  [Sito Web DELETE Bucket nella pagina](https://docs.aws.amazon.com/AmazonS3/latest/API/RESTBucketDELETEwebsite.html) di riferimento dell'API Amazon Simple Storage Service

# Utilizzo TransferManager per le operazioni di Amazon S3
<a name="examples-s3-transfermanager"></a>

Puoi utilizzare la AWS SDK per C\$1\$1 `TransferManager` classe per trasferire in modo affidabile file dall'ambiente locale ad Amazon S3 e copiare oggetti da una posizione Amazon S3 a un'altra. `TransferManager`può visualizzare lo stato di avanzamento di un trasferimento e mettere in pausa o riprendere i caricamenti e i download.

**Nota**  
Per evitare di ricevere addebiti per caricamenti incompleti o parziali, ti consigliamo di abilitare la regola del [AbortIncompleteMultipartUpload](https://docs.aws.amazon.com/AmazonS3/latest/userguide/mpu-abort-incomplete-mpu-lifecycle-config.html)ciclo di vita sui tuoi bucket Amazon S3.  
Questa regola impone ad Amazon S3 di interrompere i caricamenti multiparte che non vengono completati entro un determinato numero di giorni dall'avvio. Quando viene superato il limite di tempo impostato, Amazon S3 interrompe il caricamento e quindi elimina i dati di caricamento incompleti.   
Per ulteriori informazioni, consulta [Impostazione della configurazione del ciclo di vita su un bucket](https://docs.aws.amazon.com/AmazonS3/latest/userguide/how-to-set-lifecycle-configuration-intro.html) nella Guida per l'utente di Amazon S3.

## Prerequisiti
<a name="codeExamplePrereq"></a>

Prima di iniziare, ti consigliamo di leggere la [Guida introduttiva](getting-started.md) all'uso di. AWS SDK per C\$1\$1

Scarica il codice di esempio e crea la soluzione come descritto in[Guida introduttiva agli esempi di codice](getting-started-code-examples.md). 

Per eseguire gli esempi, il profilo utente utilizzato dal codice per effettuare le richieste deve disporre delle autorizzazioni appropriate AWS (per il servizio e l'azione). Per ulteriori informazioni, vedere [Fornitura di AWS credenziali](credentials.md).

## Caricamento e download di oggetti utilizzando `TransferManager`
<a name="stream"></a>

Questo esempio dimostra come [https://docs.aws.amazon.com/sdk-for-cpp/latest/api/aws-cpp-sdk-transfer/html/class_aws_1_1_transfer_1_1_transfer_manager.html](https://docs.aws.amazon.com/sdk-for-cpp/latest/api/aws-cpp-sdk-transfer/html/class_aws_1_1_transfer_1_1_transfer_manager.html)trasferisce oggetti di grandi dimensioni in memoria. `UploadFile`e `DownloadFile` i metodi vengono entrambi chiamati in modo asincrono e restituiscono `TransferHandle` a per gestire lo stato della richiesta. Se l'oggetto caricato è più grande di `bufferSize` allora verrà eseguito un caricamento in più parti. Il `bufferSize` valore predefinito è 5 MB, ma può essere configurato tramite. [https://docs.aws.amazon.com/sdk-for-cpp/latest/api/aws-cpp-sdk-transfer/html/struct_aws_1_1_transfer_1_1_transfer_manager_configuration.html](https://docs.aws.amazon.com/sdk-for-cpp/latest/api/aws-cpp-sdk-transfer/html/struct_aws_1_1_transfer_1_1_transfer_manager_configuration.html) 

```
        auto s3_client = Aws::MakeShared<Aws::S3::S3Client>("S3Client");
        auto executor = Aws::MakeShared<Aws::Utils::Threading::PooledThreadExecutor>("executor", 25);
        Aws::Transfer::TransferManagerConfiguration transfer_config(executor.get());
        transfer_config.s3Client = s3_client;

        // Create buffer to hold data received by the data stream.
        Aws::Utils::Array<unsigned char> buffer(BUFFER_SIZE);

        // The local variable 'streamBuffer' is captured by reference in a lambda.
        // It must persist until all downloading by the 'transfer_manager' is complete.
        Stream::PreallocatedStreamBuf streamBuffer(buffer.GetUnderlyingData(), buffer.GetLength());

        auto transfer_manager = Aws::Transfer::TransferManager::Create(transfer_config);

        auto uploadHandle = transfer_manager->UploadFile(LOCAL_FILE, BUCKET, KEY, "text/plain", Aws::Map<Aws::String, Aws::String>());
        uploadHandle->WaitUntilFinished();
        bool success = uploadHandle->GetStatus() == Transfer::TransferStatus::COMPLETED; 
      
        if (!success)
        {
            auto err = uploadHandle->GetLastError();           
            std::cout << "File upload failed:  "<< err.GetMessage() << std::endl;
        }
        else
        {
            std::cout << "File upload finished." << std::endl;

            auto downloadHandle = transfer_manager->DownloadFile(BUCKET,
                KEY,
                [&]() { //Define a lambda expression for the callback method parameter to stream back the data.
                    return Aws::New<MyUnderlyingStream>("TestTag", &streamBuffer);
                });
            downloadHandle->WaitUntilFinished();// Block calling thread until download is complete.
            auto downStat = downloadHandle->GetStatus();
            if (downStat != Transfer::TransferStatus::COMPLETED)
            {
                auto err = downloadHandle->GetLastError();
                std::cout << "File download failed:  " << err.GetMessage() << std::endl;
            }
            std::cout << "File download to memory finished."  << std::endl;
```

Vedi l'[esempio completo](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code/transfer-manager/transferOnStream.cpp) su GitHub.

# Utilizzo `S3CrtClient` per le operazioni di Amazon S3
<a name="examples-s3-crt"></a>

La `S3CrtClient` classe è disponibile nella versione 1.9 di AWS SDK per C\$1\$1 e migliora la velocità di caricamento e download di file di dati di grandi dimensioni da e verso Amazon S3. Per ulteriori informazioni sui miglioramenti di questa versione, consulta Improving [Amazon S3 Throughput with v1.9 AWS SDK per C\$1\$1](https://github.com/aws/aws-sdk-cpp/wiki/Improving-S3-Throughput-with-AWS-SDK-for-CPP-v1.9)

`S3CrtClient`È implementato nella parte superiore delle librerie [AWS Common Runtime (CRT)](https://docs.aws.amazon.com/sdkref/latest/guide/common-runtime.html).

**Nota**  
Per evitare di ricevere addebiti per caricamenti incompleti o parziali, ti consigliamo di abilitare la regola del [AbortIncompleteMultipartUpload](https://docs.aws.amazon.com/AmazonS3/latest/userguide/mpu-abort-incomplete-mpu-lifecycle-config.html)ciclo di vita sui tuoi bucket Amazon S3.  
Questa regola impone ad Amazon S3 di interrompere i caricamenti multiparte che non vengono completati entro un determinato numero di giorni dall'avvio. Quando viene superato il limite di tempo impostato, Amazon S3 interrompe il caricamento e quindi elimina i dati di caricamento incompleti.   
Per ulteriori informazioni, consulta [Impostazione della configurazione del ciclo di vita su un bucket](https://docs.aws.amazon.com/AmazonS3/latest/userguide/how-to-set-lifecycle-configuration-intro.html) nella Guida per l'utente di Amazon S3.

## Prerequisiti
<a name="codeExamplePrereq"></a>

Prima di iniziare, ti consigliamo di leggere la [Guida introduttiva](getting-started.md) all'uso di. AWS SDK per C\$1\$1

Scarica il codice di esempio e crea la soluzione come descritto in[Guida introduttiva agli esempi di codice](getting-started-code-examples.md). 

Per eseguire gli esempi, il profilo utente utilizzato dal codice per effettuare le richieste deve disporre delle autorizzazioni appropriate AWS (per il servizio e l'azione). Per ulteriori informazioni, vedere [Fornitura di AWS credenziali](credentials.md).

## Caricamento e download di oggetti utilizzando `S3CrtClient`
<a name="stream"></a>

Questo esempio dimostra come utilizzare il [https://docs.aws.amazon.com/sdk-for-cpp/latest/api/aws-cpp-sdk-s3-crt/html/class_aws_1_1_s3_crt_1_1_s3_crt_client.html](https://docs.aws.amazon.com/sdk-for-cpp/latest/api/aws-cpp-sdk-s3-crt/html/class_aws_1_1_s3_crt_1_1_s3_crt_client.html). L'esempio crea un bucket, carica un oggetto, scarica l'oggetto, quindi elimina il file e il bucket. Un'operazione PUT si trasforma in un caricamento in più parti. Un'operazione GET si trasforma in più richieste GET «a intervalli». Per ulteriori informazioni sui caricamenti in più parti, consulta [Caricamento e copia di oggetti utilizzando il caricamento in più parti nella](https://docs.aws.amazon.com/AmazonS3/latest/userguide/mpuoverview.html) Amazon S3 User Guide. 

In questo esempio, `ny.json` il file di dati fornito viene caricato come caricamento in più parti. Ciò può essere confermato visualizzando i log di debug dopo una corretta esecuzione del programma.

Se il caricamento fallisce, `AbortMultipartUpload` viene emesso un file nella libreria CRT sottostante per ripulire le parti già caricate. Tuttavia, non tutti i guasti possono essere gestiti internamente (ad esempio lo scollegamento di un cavo di rete). Ti consigliamo di creare una regola del ciclo di vita sul tuo bucket Amazon S3 per garantire che i dati caricati parzialmente non rimangano sul tuo account (i dati caricati parzialmente sono comunque fatturabili). Per scoprire come configurare una regola del ciclo di vita, consulta [Discovering and Deleting Incomplete Multipart Uploads to Lower Amazon](https://aws.amazon.com/blogs/aws-cost-management/discovering-and-deleting-incomplete-multipart-uploads-to-lower-amazon-s3-costs/ ) S3 Costs. 

**Utilizzo del log di debug per esplorare i dettagli dei caricamenti in più parti**

1. Nota che ci sono "TODO" commenti con istruzioni per l'aggiornamento del codice. `main()`

   1. Per`file_name`: dal link fornito nel commento al codice`ny.json`, scarica un file di dati di esempio o usa un file di dati di grandi dimensioni tutto tuo.

   1. Per`region`: aggiorna la `region` variabile, usando l'enum, alla variabile Regione AWS del tuo account. Per trovare la regione del tuo account, accedi a e individua la regione nell'angolo in alto a destra. Console di gestione AWS

1. Crea l'esempio.

1. Copia il file specificato dalla variabile nella `file_name` cartella eseguibile ed esegui l'`s3-crt-demo`eseguibile.

1. Nella cartella eseguibile, trova il `.log` file più recente.

1. Apri il file di registro, seleziona **cerca** e inserisci**partNumber**.

1. Il registro contiene voci simili alle seguenti, in cui `uploadId` sono specificati gli `partNumber` e per ogni parte del file caricato:

    `PUT /my-object partNumber=1&uploadId=gsk8vDbmnlA5EseDo._LDEgq22Qmt0SeuszYxMsZ9ABt503VqDIFOP8xzZI1P0zp.ToS.qo5kK16HNWogZF3KpRo.Dc7QnLZIK0BTmzCWwWoPax4T21hvP6nPdz9591F content-length:8388608 host:my-bucketasdfasdf.s3.us-east-2.amazonaws.com x-amz-content-sha256:UNSIGNED-PAYLOAD`

    and 

    `PUT /my-object partNumber=2&uploadId=gsk8vDbmnlA5EseDo._LDEgq22Qmt0SeuszYxMsZ9ABt503VqDIFOP8xzZI1P0zp.ToS.qo5kK16HNWogZF3KpRo.Dc7QnLZIK0BTmzCWwWoPax4T21hvP6nPdz9591F content-length:8388608 host:my-bucketasdfasdf.s3.us-east-2.amazonaws.com x-amz-content-sha256:UNSIGNED-PAYLOAD `

Vedi l'[esempio completo](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code/s3-crt/s3-crt-demo.cpp) su GitHub.