Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.

# Exemples de code Amazon S3 utilisant le AWS SDK pour C\$1\$1
<a name="examples-s3"></a>

[Amazon S3](https://aws.amazon.com/s3) est un système de stockage d'objets conçu pour stocker et récupérer n'importe quel volume de données, où que vous soyez. Plusieurs classes sont fournies par l'interface AWS SDK pour C\$1\$1 to avec Amazon S3. 

**Note**  
Seul le code nécessaire pour démontrer certaines techniques est fourni dans ce guide, mais l'[exemple de code complet est disponible sur GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp). GitHub Vous pouvez télécharger un seul fichier source ou cloner le référentiel localement pour obtenir, créer et exécuter tous les exemples.
+ 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` bibliothèque est une interface Amazon S3 complète.

  L'`list_buckets_disabling_dns_cache.cpp`exemple de cet ensemble est spécifiquement conçu pour fonctionner avec CURL activé Linux/Mac (mais peut être modifié pour fonctionner sous Windows). Si vous êtes sous Windows, supprimez le fichier `list_buckets_disabling_dns_cache.cpp` avant de créer le projet car il repose sur le curl HttpClient de Linux.

  L'exemple de code utilisant le `S3Client` se trouve dans le [`s3`dossier](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code/s3) sur Github. Consultez le [fichier Readme](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code/s3/README.md) sur Github pour une liste complète des fonctions illustrées par cet ensemble d'exemples.

  Certaines parties de l'ensemble d'`s3`exemples sont abordées de manière plus détaillée dans ce guide :
  + [Création, mise en liste et suppression de buckets](examples-s3-buckets.md)
  + [Opérations sur des objets](examples-s3-objects.md)— Chargement et téléchargement d'objets de données
  + [Gestion des autorisations d'accès Amazon S3](examples-s3-access-permissions.md)
  + [Gestion de l'accès aux compartiments Amazon S3 à l'aide des politiques relatives aux compartiments](examples-s3-bucket-policies.md)
  + [Configuration d'un compartiment Amazon S3 en tant que site 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`Il a été ajouté dans la version 1.9 du SDK. `S3CrtClient`fournit un débit élevé pour les opérations GET (téléchargement) et PUT (téléchargement) d'Amazon S3. Le `S3CrtClient` est implémenté au-dessus des bibliothèques AWS Common Runtime (CRT). 

  L'exemple de code utilisant le `S3CrtClient` se trouve dans le [`s3-crt`dossier](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code/s3-crt) sur Github. Consultez le [fichier Readme](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code/s3-crt/README.md) sur Github pour une liste complète des fonctions illustrées par cet ensemble d'exemples.
  + [Utilisation `S3CrtClient` pour les opérations 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`est un service entièrement géré qui permet le transfert de fichiers via le protocole de transfert de fichiers (FTP), le protocole de transfert de fichiers via SSL (FTPS) ou le protocole de transfert de fichiers (SFTP) Secure Shell (SSH) directement depuis et vers Amazon S3.

  L'exemple de code utilisant le `TransferManager` se trouve dans le [`transfer-manager`dossier](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code/transfer-manager) sur Github. Consultez le [fichier Readme](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code/transfer-manager/README.md) sur Github pour une liste complète des fonctions illustrées par cet ensemble d'exemples.
  + [Utilisation TransferManager pour les opérations Amazon S3](examples-s3-transfermanager.md)

# Création, mise en liste et suppression de buckets
<a name="examples-s3-buckets"></a>

Chaque *objet* ou fichier d'Amazon Simple Storage Service (Amazon S3) est contenu dans *un bucket, qui représente un* dossier d'objets. Chaque compartiment possède un nom unique au monde AWS. Pour plus d'informations, consultez la section [Utilisation des compartiments Amazon S3](https://docs.aws.amazon.com/AmazonS3/latest/dev/UsingBucket.html) dans le guide de l'utilisateur d'Amazon Simple Storage Service.

## Prérequis
<a name="codeExamplePrereq"></a>

Avant de commencer, nous vous recommandons de lire [Commencer à utiliser le AWS SDK pour C\$1\$1](getting-started.md). 

Téléchargez l'exemple de code et créez la solution comme décrit dans[Commencer par des exemples de code](getting-started-code-examples.md). 

Pour exécuter les exemples, le profil utilisateur que votre code utilise pour effectuer les demandes doit disposer des autorisations appropriées AWS (pour le service et l'action). Pour plus d'informations, consultez la section [Fourniture AWS d'informations d'identification](credentials.md).

## Lister les compartiments
<a name="list-buckets"></a>

Pour exécuter cet `list_buckets` exemple, à l'invite de commande, accédez au dossier dans lequel votre système de génération crée vos exécutables de génération. Exécutez l'exécutable comme suit `run_list_buckets` (le nom de fichier complet de votre exécutable sera différent en fonction de votre système d'exploitation). La sortie répertorie les compartiments de votre compte si vous en avez, ou affiche une liste vide si vous n'en avez pas.

Dans`list_buckets.cpp`, il existe deux méthodes.
+ `main()`appels`ListBuckets()`. 
+ `ListBuckets()`utilise le SDK pour interroger vos buckets.

L'`S3Client`objet appelle la `ListBuckets()` méthode du SDK. En cas de succès, la méthode renvoie un `ListBucketOutcome` objet contenant un `ListBucketResult` objet. L'`ListBucketResult`objet appelle la `GetBuckets()` méthode pour obtenir une liste d'`Bucket`objets contenant des informations sur chaque compartiment Amazon S3 de votre compte.

 **Code** 

```
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;
}
```

Consultez l'[exemple complet de list\$1buckets](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code/s3/list_buckets.cpp) sur Github.

## Création d’un compartiment
<a name="create-bucket"></a>



Pour exécuter cet `create_bucket` exemple, à l'invite de commande, accédez au dossier dans lequel votre système de génération crée vos exécutables de génération. Exécutez l'exécutable comme suit `run_create_bucket` (le nom de fichier complet de votre exécutable sera différent en fonction de votre système d'exploitation). Le code crée un compartiment vide sous votre compte, puis affiche le succès ou l'échec de la demande.

Dans`create_bucket.cpp`, il existe deux méthodes. 
+ `main()`appels`CreateBucket()`. Dans`main()`, vous devez Région AWS modifier la région de votre compte en utilisant le`enum`. Vous pouvez consulter la région de votre compte en vous connectant au [AWS Management Console](https://console.aws.amazon.com/)et en localisant la région dans le coin supérieur droit. 
+ `CreateBucket()`utilise le SDK pour créer un bucket. 



L'`S3Client`objet appelle la `CreateBucket()` méthode du SDK en transmettant un `CreateBucketRequest` avec le nom du compartiment. Par défaut, les buckets sont créés dans la région *us-east-1 (Virginie* du Nord). Si votre région n'est pas *us-east-1*, le code définit une contrainte de compartiment pour garantir que le compartiment est créé dans votre région.

 **Code** 

```
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();
}
```

Consultez l'[exemple complet de create\$1buckets](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code/s3/create_bucket.cpp) sur Github.

## Supprimer un compartiment
<a name="delete-bucket"></a>



Pour exécuter cet `delete_bucket` exemple, à l'invite de commande, accédez au dossier dans lequel votre système de génération crée vos exécutables de génération. Exécutez l'exécutable comme suit `run_delete_bucket` (le nom de fichier complet de votre exécutable sera différent en fonction de votre système d'exploitation). Le code supprime le compartiment spécifié dans votre compte, puis affiche le succès ou l'échec de la demande.

`delete_bucket.cpp`Il existe deux méthodes. 
+ `main()`appels`DeleteBucket()`. Dans`main()`, vous devez Région AWS modifier la région de votre compte en utilisant le`enum`. Vous devez également `bucket_name` remplacer le nom du compartiment à supprimer. 
+ `DeleteBucket()`utilise le SDK pour supprimer le compartiment. 



L'`S3Client`objet utilise la `DeleteBucket()` méthode du SDK, en transmettant un `DeleteBucketRequest` objet portant le nom du compartiment à supprimer. Le compartiment doit être vide pour que cela fonctionne.

 **Code**

```
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();
}
```

Consultez l'[exemple complet de delete\$1bucket](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code/s3/delete_bucket.cpp) sur Github.

# Opérations sur des objets
<a name="examples-s3-objects"></a>

Un objet Amazon S3 représente un *fichier*, qui est un ensemble de données. Chaque objet doit résider dans un [compartiment](examples-s3-buckets.md).

## Conditions préalables
<a name="codeExamplePrereq"></a>

Avant de commencer, nous vous recommandons de lire [Commencer à utiliser le AWS SDK pour C\$1\$1](getting-started.md). 

Téléchargez l'exemple de code et créez la solution comme décrit dans[Commencer par des exemples de code](getting-started-code-examples.md). 

Pour exécuter les exemples, le profil utilisateur que votre code utilise pour effectuer les demandes doit disposer des autorisations appropriées AWS (pour le service et l'action). Pour plus d'informations, consultez la section [Fourniture AWS d'informations d'identification](credentials.md).

## Charger un fichier dans un bucket
<a name="upload-object"></a>

Utilisez la `PutObject` fonction `S3Client` object en lui fournissant le nom du bucket, le nom de la clé et le fichier à télécharger. `Aws::FStream`est utilisé pour télécharger le contenu du fichier local dans le bucket. Le bucket doit exister, sinon une erreur se produira.

Pour un exemple de chargement asynchrone d'objets, voir [Programmation asynchrone à l'aide du AWS SDK pour C\$1\$1](async-methods.md)

 **Code** 

```
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();
}
```

Consultez l'exemple complet sur [GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code/s3/put_object.cpp).

## Charger une chaîne dans un bucket
<a name="upload-object-string"></a>

Utilisez la `PutObject` fonction `S3Client` object en lui fournissant le nom du bucket, le nom de la clé et le fichier à télécharger. Le bucket doit exister, sinon une erreur se produira. Cet exemple diffère du précédent en ce qu'il permet `Aws::StringStream` de télécharger un objet de données de chaîne en mémoire directement dans un bucket.

Pour un exemple de chargement asynchrone d'objets, voir [Programmation asynchrone à l'aide du AWS SDK pour C\$1\$1](async-methods.md)

 **Code** 

```
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();
}
```

Consultez l'exemple complet sur [GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code/s3/put_object_buffer.cpp).

## Répertorier les objets
<a name="list-objects"></a>

Pour obtenir la liste des objets contenus dans un compartiment, utilisez la `ListObjects` fonction `S3Client` object. Fournissez-lui un nom `ListObjectsRequest` que vous avez défini avec le nom d'un bucket dont vous souhaitez répertorier le contenu.

La `ListObjects` fonction renvoie un `ListObjectsOutcome` objet que vous pouvez utiliser pour obtenir une liste d'objets sous forme d'`Object`instances.

 **Code** 

```
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;
}
```

Consultez l'exemple complet sur [GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code/s3/list_objects.cpp).

## Télécharger un objet
<a name="download-object"></a>

Utilisez la `GetObject` fonction `S3Client` object, en lui transmettant un `GetObjectRequest` que vous avez défini avec le nom d'un bucket et la clé de l'objet à télécharger. `GetObject`renvoie 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)objet composé de 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)et [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)a. `GetObjectResult`peut être utilisé pour accéder aux données de l'objet S3.

L'exemple suivant télécharge un objet depuis Amazon S3. Le contenu de l'objet est stocké dans une variable locale et la première ligne du contenu est envoyée à la console.

 **Code** 

```
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();
}
```

Consultez l'exemple complet sur [GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code/s3/get_object.cpp).

## Supprimer un objet
<a name="delete-object"></a>

Utilisez la `DeleteObject` fonction de l'`S3Client`objet en lui transmettant un nom `DeleteObjectRequest` que vous avez défini avec le nom du bucket et de l'objet à télécharger. *Le compartiment et la clé d'objet spécifiés doivent exister, sinon une erreur se produira*.

 **Code** 

```
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();
}
```

Consultez l'exemple complet sur [GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code/s3/delete_object.cpp).

# Gestion des autorisations d'accès Amazon S3
<a name="examples-s3-access-permissions"></a>

Les autorisations d'accès pour un compartiment ou un objet Amazon S3 sont définies dans une liste de contrôle d'accès (ACL). L'ACL indique le propriétaire de la bucket/object et une liste de subventions. Chaque autorisation spécifie un utilisateur (ou bénéficiaire) et les autorisations de l'utilisateur pour accéder au bucket ou à l'objet, telles que l'accès READ ou WRITE.

## Conditions préalables
<a name="codeExamplePrereq"></a>

Avant de commencer, nous vous recommandons de lire [Commencer à utiliser le AWS SDK pour C\$1\$1](getting-started.md). 

Téléchargez l'exemple de code et créez la solution comme décrit dans[Commencer par des exemples de code](getting-started-code-examples.md). 

Pour exécuter les exemples, le profil utilisateur que votre code utilise pour effectuer les demandes doit disposer des autorisations appropriées AWS (pour le service et l'action). Pour plus d'informations, consultez la section [Fourniture AWS d'informations d'identification](credentials.md).

## Gérer la liste de contrôle d'accès d'un objet
<a name="manage-an-object-s-access-control-list"></a>

La liste de contrôle d'accès d'un objet peut être récupérée en appelant la `S3Client` méthode`GetObjectAcl`. La méthode accepte les noms de l'objet et de son compartiment. La valeur de retour inclut les ACL `Owner` et la liste des`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 peut être modifiée soit en créant une nouvelle ACL, soit en modifiant les autorisations spécifiées dans l'ACL actuelle. L'ACL mise à jour devient la nouvelle ACL actuelle en la transmettant à la `PutObjectAcl` méthode.

Le code suivant utilise l'ACL récupérée par `GetObjectAcl` et y ajoute une nouvelle autorisation. L'utilisateur ou le bénéficiaire reçoit l'autorisation READ pour l'objet. L'ACL modifiée est transmise à`PutObjectAcl`, ce qui en fait la nouvelle ACL actuelle. 

```
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;
}
```

Consultez l'exemple complet sur [GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code/s3/get_put_object_acl.cpp).

## Gérer la liste de contrôle d'accès d'un bucket
<a name="manage-a-bucket-s-access-control-list"></a>

Dans la plupart des cas, la méthode préférée pour définir les autorisations d'accès d'un bucket consiste à définir une politique de bucket. Toutefois, les buckets prennent également en charge les listes de contrôle d'accès pour les utilisateurs qui souhaitent les utiliser.

La gestion d'une liste de contrôle d'accès pour un bucket est identique à celle utilisée pour un objet. La `GetBucketAcl` méthode récupère l'ACL actuel d'un bucket et `PutBucketAcl` applique une nouvelle ACL au bucket.

Le code suivant montre comment obtenir et configurer une ACL de 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;
}
```

Consultez l'exemple complet sur [GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code/s3/get_put_bucket_acl.cpp).

# Gestion de l'accès aux compartiments Amazon S3 à l'aide des politiques relatives aux compartiments
<a name="examples-s3-bucket-policies"></a>

Vous pouvez définir, obtenir ou supprimer une *politique de compartiment* pour gérer l'accès à vos compartiments Amazon S3.

## Conditions préalables
<a name="codeExamplePrereq"></a>

Avant de commencer, nous vous recommandons de lire [Commencer à utiliser le AWS SDK pour C\$1\$1](getting-started.md). 

Téléchargez l'exemple de code et créez la solution comme décrit dans[Commencer par des exemples de code](getting-started-code-examples.md). 

Pour exécuter les exemples, le profil utilisateur que votre code utilise pour effectuer les demandes doit disposer des autorisations appropriées AWS (pour le service et l'action). Pour plus d'informations, consultez la section [Fourniture AWS d'informations d'identification](credentials.md).

## Définition d'une stratégie de compartiment
<a name="set-s3-bucket-policy"></a>

Vous pouvez définir la politique de compartiment pour un compartiment S3 particulier en appelant la `PutBucketPolicy` fonction `S3Client`'s et en lui fournissant le nom du compartiment et la représentation JSON de la politique dans 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).

 **Code** 

```
//! 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();
}
```

**Note**  
La classe JsonValue utilitaire [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) peut être utilisée pour vous aider à créer des objets JSON valides auxquels vous pouvez les transmettre. `PutBucketPolicy`

Consultez l'exemple complet sur [GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code/s3/put_bucket_policy.cpp).

## Obtention d'une stratégie de compartiment
<a name="get-s3-bucket-policy"></a>

Pour récupérer la politique d'un compartiment Amazon S3, appelez la `GetBucketPolicy` fonction `S3Client`'s en lui transmettant le nom du compartiment dans 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).

 **Code** 

```
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();
}
```

Consultez l'exemple complet sur [GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code/s3/get_bucket_policy.cpp).

## Suppression d'une stratégie de compartiment
<a name="delete-s3-bucket-policy"></a>

Pour supprimer une politique de compartiment, appelez la `DeleteBucketPolicy` fonction `S3Client`'s en lui fournissant le nom du compartiment dans 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).

 **Code** 

```
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();
}
```

Cette fonction fonctionne même si le bucket n'a pas encore de politique. Si vous spécifiez un nom de compartiment qui n'existe pas ou si vous n'avez pas accès au compartiment, une exception `AmazonServiceException` est levée.

Consultez l'exemple complet sur [GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code/s3/delete_bucket_policy.cpp).

## Plus d'informations
<a name="more-info"></a>
+  [PutBucketPolicy](https://docs.aws.amazon.com/AmazonS3/latest/API/PutBucketPolicy.html)dans le manuel Amazon Simple Storage Service API Reference
+  [GetBucketPolicy](https://docs.aws.amazon.com/AmazonS3/latest/API/GetBucketPolicy.html)dans le manuel Amazon Simple Storage Service API Reference
+  [DeleteBucketPolicy](https://docs.aws.amazon.com/AmazonS3/latest/API/DeleteBucketPolicy.html)dans le manuel Amazon Simple Storage Service API Reference
+  [Présentation du langage de la politique d'accès](https://docs.aws.amazon.com/AmazonS3/latest/dev/access-policy-language-overview.html) dans le guide de l'utilisateur d'Amazon Simple Storage Service
+  [Exemples de politiques relatives](https://docs.aws.amazon.com/AmazonS3/latest/dev/example-bucket-policies.html) aux compartiments dans le guide de l'utilisateur d'Amazon Simple Storage Service

# Configuration d'un compartiment Amazon S3 en tant que site Web
<a name="examples-s3-website-configuration"></a>

Vous pouvez configurer un compartiment Amazon S3 pour qu'il se comporte comme un site Web. Pour ce faire, vous devez définir sa configuration de site web.

## Conditions préalables
<a name="codeExamplePrereq"></a>

Avant de commencer, nous vous recommandons de lire [Commencer à utiliser le AWS SDK pour C\$1\$1](getting-started.md). 

Téléchargez l'exemple de code et créez la solution comme décrit dans[Commencer par des exemples de code](getting-started-code-examples.md). 

Pour exécuter les exemples, le profil utilisateur que votre code utilise pour effectuer les demandes doit disposer des autorisations appropriées AWS (pour le service et l'action). Pour plus d'informations, consultez la section [Fourniture AWS d'informations d'identification](credentials.md).

## Définition de la configuration de site web d'un compartiment
<a name="set-a-bucket-s-website-configuration"></a>

Pour définir la configuration du site Web d'un compartiment Amazon S3, appelez la `PutBucketWebsite` fonction `S3Client`'s avec 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)objet contenant le nom du compartiment et la configuration de son site Web, fournis dans un [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)objet.

La définition d'un document d'index est *obligatoire* ; tous les autres paramètres sont facultatifs.

 **Code** 

```
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();
}
```

**Note**  
La définition d'une configuration de site web ne modifie pas les autorisations d'accès de votre compartiment. Pour que vos fichiers soient visibles sur le web, vous devez également définir une *stratégie de compartiment* qui autorise l'accès en lecture public aux fichiers du compartiment. Pour plus d'informations, consultez [Gestion de l'accès aux compartiments Amazon S3 à l'aide de stratégies de compartiment](examples-s3-bucket-policies.md).

Consultez l'exemple complet sur [GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code/s3/put_website_config.cpp).

## Obtention de la configuration de site web d'un compartiment
<a name="get-a-bucket-s-website-configuration"></a>

Pour obtenir la configuration du site Web d'un compartiment Amazon S3, appelez la `GetBucketWebsite` fonction `S3Client`'s avec un [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)contenant le nom du compartiment pour lequel vous souhaitez récupérer la configuration.

La configuration sera renvoyée sous forme d'[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)objet dans l'objet de résultat. S'il n'y a pas de configuration de site web pour le compartiment, la valeur `null` est renvoyée.

 **Code** 

```
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();
}
```

Consultez l'exemple complet sur [GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code/s3/get_website_config.cpp).

## Suppression de la configuration de site web d'un compartiment
<a name="delete-a-bucket-s-website-configuration"></a>

Pour supprimer la configuration du site Web d'un compartiment Amazon S3, appelez la `DeleteBucketWebsite` fonction `S3Client`'s avec 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): contenant le nom du compartiment dont vous souhaitez supprimer la configuration.

 **Code** 

```
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();
}
```

Consultez l'exemple complet sur [GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code/s3/delete_website_config.cpp).

## En savoir plus
<a name="more-information"></a>
+  Le [site Web PUT Bucket](https://docs.aws.amazon.com/AmazonS3/latest/API/RESTBucketPUTwebsite.html) dans le manuel de référence de l'API Amazon Simple Storage Service
+  [Site Web GET Bucket](https://docs.aws.amazon.com/AmazonS3/latest/API/RESTBucketGETwebsite.html) dans le manuel de référence de l'API Amazon Simple Storage Service
+  Le [site Web DELETE Bucket](https://docs.aws.amazon.com/AmazonS3/latest/API/RESTBucketDELETEwebsite.html) dans le manuel de référence de l'API Amazon Simple Storage Service

# Utilisation TransferManager pour les opérations Amazon S3
<a name="examples-s3-transfermanager"></a>

Vous pouvez utiliser cette AWS SDK pour C\$1\$1 `TransferManager` classe pour transférer de manière fiable des fichiers de l'environnement local vers Amazon S3 et pour copier des objets d'un emplacement Amazon S3 à un autre. `TransferManager`peut suivre la progression d'un transfert et suspendre ou reprendre les chargements et les téléchargements.

**Note**  
Pour éviter d'être facturé pour des téléchargements incomplets ou partiels, nous vous recommandons d'activer la règle du [AbortIncompleteMultipartUpload](https://docs.aws.amazon.com/AmazonS3/latest/userguide/mpu-abort-incomplete-mpu-lifecycle-config.html)cycle de vie sur vos compartiments Amazon S3.  
Cette règle oblige Amazon S3 à abandonner les téléchargements partitionnés qui ne se terminent pas dans un certain nombre de jours après leur lancement. Lorsque le délai défini est dépassé, Amazon S3 abandonne le téléchargement, puis supprime les données de téléchargement incomplètes.   
Pour plus d'informations, consultez la section [Configuration de la configuration du cycle de vie d'un compartiment](https://docs.aws.amazon.com/AmazonS3/latest/userguide/how-to-set-lifecycle-configuration-intro.html) dans le guide de l'utilisateur Amazon S3.

## Conditions préalables
<a name="codeExamplePrereq"></a>

Avant de commencer, nous vous recommandons de lire [Commencer à utiliser le AWS SDK pour C\$1\$1](getting-started.md). 

Téléchargez l'exemple de code et créez la solution comme décrit dans[Commencer par des exemples de code](getting-started-code-examples.md). 

Pour exécuter les exemples, le profil utilisateur que votre code utilise pour effectuer les demandes doit disposer des autorisations appropriées AWS (pour le service et l'action). Pour plus d'informations, consultez la section [Fourniture AWS d'informations d'identification](credentials.md).

## Chargement et téléchargement de l'objet à l'aide de `TransferManager`
<a name="stream"></a>

Cet exemple montre comment [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)transférer des objets volumineux en mémoire. `UploadFile`et les `DownloadFile` méthodes sont toutes deux appelées de manière asynchrone et renvoient un `TransferHandle` pour gérer le statut de votre demande. Si l'objet téléchargé est plus grand que celui-ci`bufferSize`, un téléchargement en plusieurs parties sera effectué. La `bufferSize` valeur par défaut est de 5 Mo, mais cela peut être configuré via. [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;
```

Consultez l'exemple complet sur [GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code/transfer-manager/transferOnStream.cpp).

# Utilisation `S3CrtClient` pour les opérations Amazon S3
<a name="examples-s3-crt"></a>

La `S3CrtClient` classe est disponible dans la version 1.9 de AWS SDK pour C\$1\$1 et améliore le débit de chargement et de téléchargement de fichiers de données volumineux vers et depuis Amazon S3. Pour plus d'informations sur les améliorations apportées à cette version, consultez [Améliorer le débit d'Amazon S3 avec AWS SDK pour C\$1\$1](https://github.com/aws/aws-sdk-cpp/wiki/Improving-S3-Throughput-with-AWS-SDK-for-CPP-v1.9) la version 1.9

Le `S3CrtClient` est implémenté au-dessus des [bibliothèques AWS Common Runtime (CRT)](https://docs.aws.amazon.com/sdkref/latest/guide/common-runtime.html).

**Note**  
Pour éviter d'être facturé pour des téléchargements incomplets ou partiels, nous vous recommandons d'activer la règle du [AbortIncompleteMultipartUpload](https://docs.aws.amazon.com/AmazonS3/latest/userguide/mpu-abort-incomplete-mpu-lifecycle-config.html)cycle de vie sur vos compartiments Amazon S3.  
Cette règle oblige Amazon S3 à abandonner les téléchargements partitionnés qui ne se terminent pas dans un certain nombre de jours après leur lancement. Lorsque le délai défini est dépassé, Amazon S3 abandonne le téléchargement, puis supprime les données de téléchargement incomplètes.   
Pour plus d'informations, consultez la section [Configuration de la configuration du cycle de vie d'un compartiment](https://docs.aws.amazon.com/AmazonS3/latest/userguide/how-to-set-lifecycle-configuration-intro.html) dans le guide de l'utilisateur Amazon S3.

## Conditions préalables
<a name="codeExamplePrereq"></a>

Avant de commencer, nous vous recommandons de lire [Commencer à utiliser le AWS SDK pour C\$1\$1](getting-started.md). 

Téléchargez l'exemple de code et créez la solution comme décrit dans[Commencer par des exemples de code](getting-started-code-examples.md). 

Pour exécuter les exemples, le profil utilisateur que votre code utilise pour effectuer les demandes doit disposer des autorisations appropriées AWS (pour le service et l'action). Pour plus d'informations, consultez la section [Fourniture AWS d'informations d'identification](credentials.md).

## Chargement et téléchargement de l'objet à l'aide de `S3CrtClient`
<a name="stream"></a>

Cet exemple montre comment utiliser le [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'exemple crée un compartiment, télécharge un objet, télécharge l'objet, puis supprime le fichier et le compartiment. Une opération PUT se transforme en un téléchargement partitionné. Une opération GET se transforme en plusieurs requêtes GET « à distance ». Pour plus d'informations sur les chargements partitionnés, consultez la section [Chargement et copie d'objets à l'aide du téléchargement partitionné dans](https://docs.aws.amazon.com/AmazonS3/latest/userguide/mpuoverview.html) le guide de l'utilisateur Amazon S3. 

Dans cet exemple`ny.json`, le fichier de données fourni est chargé en plusieurs parties. Cela peut être confirmé en consultant les journaux de débogage après une exécution réussie du programme.

Si le téléchargement échoue, un code `AbortMultipartUpload` est émis dans la bibliothèque CRT sous-jacente pour nettoyer les parties déjà téléchargées. Cependant, toutes les défaillances ne peuvent pas être traitées en interne (par exemple, le débranchement d'un câble réseau). Il est recommandé de créer une règle de cycle de vie sur votre compartiment Amazon S3 afin de garantir que les données partiellement téléchargées ne restent pas sur votre compte (les données partiellement téléchargées sont toujours facturables). Pour savoir comment configurer une règle de cycle de vie, consultez la section [Découverte et suppression de téléchargements partitionnés incomplets afin de réduire les coûts liés à Amazon S3](https://aws.amazon.com/blogs/aws-cost-management/discovering-and-deleting-incomplete-multipart-uploads-to-lower-amazon-s3-costs/ ). 

**Utilisation du journal de débogage pour explorer les détails du téléchargement en plusieurs parties**

1. Dans`main()`, notez qu'il y a des commentaires TODO « » avec des instructions pour mettre à jour le code.

   1. Pour `file_name` : À partir du lien fourni dans le commentaire du code`ny.json`, téléchargez un exemple de fichier de données ou utilisez votre propre fichier de données volumineux.

   1. Pour `region` : mettez à jour la `region` variable, à l'aide de l'énumération, sur celle Région AWS de votre compte. Pour trouver la région associée à votre compte, connectez-vous au AWS Management Console et localisez la région dans le coin supérieur droit.

1. Construisez l'exemple.

1. Copiez le fichier spécifié par variable `file_name` dans votre dossier exécutable et lancez le `s3-crt-demo` fichier exécutable.

1. Dans votre dossier exécutable, recherchez le `.log` fichier le plus récent.

1. Ouvrez le fichier journal, sélectionnez **Rechercher**, puis entrez**partNumber**.

1. Le journal contient des entrées similaires aux suivantes, où les `partNumber` et `uploadId` sont spécifiés pour chaque partie du fichier téléchargé :

    `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 `

Consultez l'exemple complet sur [GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code/s3-crt/s3-crt-demo.cpp).