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 guidés d'appels Services AWS à l'aide du AWS SDK for C\$1\$1
<a name="programming-services"></a>

Si vous ne connaissez pas les exemples de AWS code, nous vous recommandons de commencer par[Commencer par des exemples de code](getting-started-code-examples.md). AWS 

Le code source qui montre comment utiliser les AWS services à l'aide de AWS SDK pour C\$1\$1 est disponible dans le [Exemples de code](cpp_code_examples.md) chapitre de ce guide ou directement dans le [référentiel d'exemples de AWS code](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code) sur GitHub. 

Cette section sélectionne plusieurs AWS services et vous guide à travers les exemples de leur utilisation. Les exemples guidés suivants sont un sous-ensemble de ce qui est disponible sur Github.


**Exemples de services avec des explications supplémentaires (voir le [référentiel d'exemples de AWS code](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code) pour la liste complète)**  

| Service | Résumé de ce que le service apporte à votre programme | 
| --- | --- | 
| [Amazon CloudWatch](examples-cloudwatch.md) | Collecte et surveille les mesures relatives AWS aux ressources que vous utilisez | 
| [Amazon DynamoDB](examples-dynamodb.md) | Un service de base de données NoSQL | 
| [Amazon Elastic Compute Cloud (Amazon EC2)](examples-ec2.md) | Capacité de calcul sécurisée et redimensionnable | 
| [Amazon Simple Storage Service (Amazon S3)](examples-s3.md) | Stockage et récupération de données (objets placés dans des compartiments) | 
| [Amazon Simple Queue Service (Amazon SQS)](examples-sqs.md) | Service de mise en file d'attente de messages pour envoyer, stocker et recevoir des messages entre les composants logiciels | 

Il existe également des exemples qui montrent comment utiliser les méthodes [asynchrones](async-methods.md).

Pour proposer un nouvel exemple de code à l'équipe de AWS documentation, consultez les [directives de contribution relatives](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/CONTRIBUTING.md) GitHub à la création d'une nouvelle demande. L'équipe préfère créer des exemples de code illustrant des scénarios généraux plutôt que des appels d'API individuels.

**Utilisation des exemples de code sous Windows**

Si vous créez les exemples sous Windows avec la version 1.9 du SDK, consultez[Résolution des problèmes liés à la compilation du AWS SDK for C\$1\$1](troubleshooting-cmake.md).

# CloudWatch Exemples Amazon utilisant le AWS SDK pour C\$1\$1
<a name="examples-cloudwatch"></a>

Amazon CloudWatch (CloudWatch) est un service de surveillance des ressources du AWS cloud et des applications que vous utilisez AWS. Vous pouvez utiliser les exemples suivants pour programmer à [CloudWatch](https://aws.amazon.com/cloudwatch)l'aide du AWS SDK pour C\$1\$1.

Amazon CloudWatch surveille vos AWS ressources et les applications que vous utilisez AWS en temps réel. Vous pouvez les utiliser CloudWatch pour collecter et suivre les métriques, qui sont des variables que vous pouvez mesurer pour vos ressources et vos applications. CloudWatchles alarmes envoient des notifications ou modifient automatiquement les ressources que vous surveillez en fonction des règles que vous définissez.

Pour plus d'informations CloudWatch, consultez le [guide de CloudWatch l'utilisateur Amazon](https://docs.aws.amazon.com/AmazonCloudWatch/latest/DeveloperGuide/).

**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.

**Topics**
+ [Obtenir des métriques à partir de CloudWatch](examples-cloudwatch-get-metrics.md)
+ [Publication de données de métriques personnalisées](examples-cloudwatch-publish-custom-metrics.md)
+ [Utilisation des CloudWatch alarmes](examples-cloudwatch-create-alarms.md)
+ [Utilisation des actions d'alarme dans CloudWatch](examples-cloudwatch-use-alarm-actions.md)
+ [Envoi d'événements à CloudWatch](examples-cloudwatch-send-events.md)

# Obtenir des métriques à partir de CloudWatch
<a name="examples-cloudwatch-get-metrics"></a>

## 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).

## Affichage de la liste des métriques
<a name="listing-metrics"></a>

Pour répertorier CloudWatch les métriques, créez une fonction [ListMetricsRequest](https://docs.aws.amazon.com/sdk-for-cpp/latest/api/aws-cpp-sdk-monitoring/html/class_aws_1_1_cloud_watch_1_1_model_1_1_list_metrics_request.html)et appelez CloudWatchClient la `ListMetrics` fonction. Vous pouvez utiliser `ListMetricsRequest` pour filtrer les métriques renvoyées par espace de noms, nom de métrique ou dimension.

**Note**  
Une liste des mesures et des dimensions publiées par les AWS services se trouve dans la [référence Amazon CloudWatch Metrics and Dimensions](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/CW_Support_For_AWS.html) du guide de CloudWatch l'utilisateur Amazon.

 **Comprend** 

```
#include <aws/core/Aws.h>
#include <aws/monitoring/CloudWatchClient.h>
#include <aws/monitoring/model/ListMetricsRequest.h>
#include <aws/monitoring/model/ListMetricsResult.h>
#include <iomanip>
#include <iostream>
```

 **Code** 

```
        Aws::CloudWatch::CloudWatchClient cw;
        Aws::CloudWatch::Model::ListMetricsRequest request;

        if (argc > 1)
        {
            request.SetMetricName(argv[1]);
        }

        if (argc > 2)
        {
            request.SetNamespace(argv[2]);
        }

        bool done = false;
        bool header = false;
        while (!done)
        {
            auto outcome = cw.ListMetrics(request);
            if (!outcome.IsSuccess())
            {
                std::cout << "Failed to list CloudWatch metrics:" <<
                    outcome.GetError().GetMessage() << std::endl;
                break;
            }

            if (!header)
            {
                std::cout << std::left << std::setw(48) << "MetricName" <<
                    std::setw(32) << "Namespace" << "DimensionNameValuePairs" <<
                    std::endl;
                header = true;
            }

            const auto &metrics = outcome.GetResult().GetMetrics();
            for (const auto &metric : metrics)
            {
                std::cout << std::left << std::setw(48) <<
                    metric.GetMetricName() << std::setw(32) <<
                    metric.GetNamespace();
                const auto &dimensions = metric.GetDimensions();
                for (auto iter = dimensions.cbegin();
                    iter != dimensions.cend(); ++iter)
                {
                    const auto &dimkv = *iter;
                    std::cout << dimkv.GetName() << " = " << dimkv.GetValue();
                    if (iter + 1 != dimensions.cend())
                    {
                        std::cout << ", ";
                    }
                }
                std::cout << std::endl;
            }

            const auto &next_token = outcome.GetResult().GetNextToken();
            request.SetNextToken(next_token);
            done = next_token.empty();
        }
```

Les métriques sont renvoyées dans un [ListMetricsResult](https://docs.aws.amazon.com/sdk-for-cpp/latest/api/aws-cpp-sdk-monitoring/html/class_aws_1_1_cloud_watch_1_1_model_1_1_list_metrics_result.html)en appelant sa `GetMetrics` fonction. Les résultats peuvent être *paginés*. Pour récupérer le lot de résultats suivant, appelez `SetNextToken` l'objet de demande d'origine avec la valeur de retour de la `GetNextToken` fonction de l'`ListMetricsResult`objet et retransmettez l'objet de demande modifié à un autre appel à`ListMetrics`.

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

## En savoir plus
<a name="more-information"></a>
+  [ListMetrics](https://docs.aws.amazon.com/AmazonCloudWatch/latest/APIReference/ListMetrics.html)dans le Amazon CloudWatch API Reference.

# Publication de données de métriques personnalisées
<a name="examples-cloudwatch-publish-custom-metrics"></a>

Un certain nombre de AWS services publient [leurs propres métriques dans des](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/aws-namespaces.html) espaces de noms en commençant par `AWS/` Vous pouvez également publier des données de métriques personnalisées en utilisant votre propre espace de noms (à condition que cela ne commence `AWS/` pas par).

## 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).

## Publication de données de métriques personnalisées
<a name="publish-custom-metric-data"></a>

Pour publier vos propres données métriques, appelez la `PutMetricData` fonction CloudWatchClient's avec un [PutMetricDataRequest](https://docs.aws.amazon.com/sdk-for-cpp/latest/api/aws-cpp-sdk-monitoring/html/class_aws_1_1_cloud_watch_1_1_model_1_1_put_metric_data_request.html). Ils `PutMetricDataRequest` doivent inclure l'espace de noms personnalisé à utiliser pour les données, ainsi que des informations sur le point de données lui-même dans un [MetricDatum](https://docs.aws.amazon.com/sdk-for-cpp/latest/api/aws-cpp-sdk-monitoring/html/class_aws_1_1_cloud_watch_1_1_model_1_1_metric_datum.html)objet.

**Note**  
Vous ne pouvez pas spécifier un espace de noms commençant `AWS/` par. Les espaces de noms commençant par `AWS/` sont réservés aux produits Amazon Web Services.

 **Comprend** 

```
#include <aws/core/Aws.h>
#include <aws/monitoring/CloudWatchClient.h>
#include <aws/monitoring/model/PutMetricDataRequest.h>
#include <iostream>
```

 **Code** 

```
        Aws::CloudWatch::CloudWatchClient cw;

        Aws::CloudWatch::Model::Dimension dimension;
        dimension.SetName("UNIQUE_PAGES");
        dimension.SetValue("URLS");

        Aws::CloudWatch::Model::MetricDatum datum;
        datum.SetMetricName("PAGES_VISITED");
        datum.SetUnit(Aws::CloudWatch::Model::StandardUnit::None);
        datum.SetValue(data_point);
        datum.AddDimensions(dimension);

        Aws::CloudWatch::Model::PutMetricDataRequest request;
        request.SetNamespace("SITE/TRAFFIC");
        request.AddMetricData(datum);

        auto outcome = cw.PutMetricData(request);
        if (!outcome.IsSuccess())
        {
            std::cout << "Failed to put sample metric data:" <<
                outcome.GetError().GetMessage() << std::endl;
        }
        else
        {
            std::cout << "Successfully put sample metric data" << std::endl;
        }
```

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

## En savoir plus
<a name="more-information"></a>
+  [Utilisation d'Amazon CloudWatch Metrics](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/working_with_metrics.html) dans le guide de CloudWatch l'utilisateur Amazon.
+  [AWS Espaces de noms](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/aws-namespaces.html) dans le guide de CloudWatch l'utilisateur Amazon.
+  [PutMetricData](https://docs.aws.amazon.com/AmazonCloudWatch/latest/APIReference/PutMetricData.html)dans le Amazon CloudWatch API Reference.

# Utilisation des CloudWatch alarmes
<a name="examples-cloudwatch-create-alarms"></a>

## 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).

## Créer une alarme
<a name="create-an-alarm"></a>

Pour créer une alarme basée sur une CloudWatch métrique, appelez la CloudWatchClient `PutMetricAlarm` fonction « s » en [PutMetricAlarmRequest](https://docs.aws.amazon.com/sdk-for-cpp/latest/api/aws-cpp-sdk-monitoring/html/class_aws_1_1_cloud_watch_1_1_model_1_1_put_metric_alarm_request.html)indiquant les conditions de l'alarme.

 **Comprend** 

```
#include <aws/core/Aws.h>
#include <aws/monitoring/CloudWatchClient.h>
#include <aws/monitoring/model/PutMetricAlarmRequest.h>
#include <iostream>
```

 **Code** 

```
        Aws::CloudWatch::CloudWatchClient cw;
        Aws::CloudWatch::Model::PutMetricAlarmRequest request;
        request.SetAlarmName(alarm_name);
        request.SetComparisonOperator(
            Aws::CloudWatch::Model::ComparisonOperator::GreaterThanThreshold);
        request.SetEvaluationPeriods(1);
        request.SetMetricName("CPUUtilization");
        request.SetNamespace("AWS/EC2");
        request.SetPeriod(60);
        request.SetStatistic(Aws::CloudWatch::Model::Statistic::Average);
        request.SetThreshold(70.0);
        request.SetActionsEnabled(false);
        request.SetAlarmDescription("Alarm when server CPU exceeds 70%");
        request.SetUnit(Aws::CloudWatch::Model::StandardUnit::Seconds);

        Aws::CloudWatch::Model::Dimension dimension;
        dimension.SetName("InstanceId");
        dimension.SetValue(instanceId);

        request.AddDimensions(dimension);

        auto outcome = cw.PutMetricAlarm(request);
        if (!outcome.IsSuccess())
        {
            std::cout << "Failed to create CloudWatch alarm:" <<
                outcome.GetError().GetMessage() << std::endl;
        }
        else
        {
            std::cout << "Successfully created CloudWatch alarm " << alarm_name
                << std::endl;
        }
```

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

## Affichage des alarmes
<a name="list-alarms"></a>

Pour répertorier les CloudWatch alarmes que vous avez créées, appelez la `DescribeAlarms` fonction CloudWatchClient's avec un [DescribeAlarmsRequest](https://docs.aws.amazon.com/sdk-for-cpp/latest/api/aws-cpp-sdk-monitoring/html/class_aws_1_1_cloud_watch_1_1_model_1_1_describe_alarms_request.html)que vous pouvez utiliser pour définir les options du résultat.

 **Comprend** 

```
#include <aws/core/Aws.h>
#include <aws/monitoring/CloudWatchClient.h>
#include <aws/monitoring/model/DescribeAlarmsRequest.h>
#include <aws/monitoring/model/DescribeAlarmsResult.h>
#include <iomanip>
#include <iostream>
```

 **Code** 

```
        Aws::CloudWatch::CloudWatchClient cw;
        Aws::CloudWatch::Model::DescribeAlarmsRequest request;
        request.SetMaxRecords(1);

        bool done = false;
        bool header = false;
        while (!done)
        {
            auto outcome = cw.DescribeAlarms(request);
            if (!outcome.IsSuccess())
            {
                std::cout << "Failed to describe CloudWatch alarms:" <<
                    outcome.GetError().GetMessage() << std::endl;
                break;
            }

            if (!header)
            {
                std::cout << std::left <<
                    std::setw(32) << "Name" <<
                    std::setw(64) << "Arn" <<
                    std::setw(64) << "Description" <<
                    std::setw(20) << "LastUpdated" <<
                    std::endl;
                header = true;
            }

            const auto &alarms = outcome.GetResult().GetMetricAlarms();
            for (const auto &alarm : alarms)
            {
                std::cout << std::left <<
                    std::setw(32) << alarm.GetAlarmName() <<
                    std::setw(64) << alarm.GetAlarmArn() <<
                    std::setw(64) << alarm.GetAlarmDescription() <<
                    std::setw(20) <<
                    alarm.GetAlarmConfigurationUpdatedTimestamp().ToGmtString(
                        SIMPLE_DATE_FORMAT_STR) <<
                    std::endl;
            }

            const auto &next_token = outcome.GetResult().GetNextToken();
            request.SetNextToken(next_token);
            done = next_token.empty();
        }
```

La liste des alarmes peut être obtenue `getMetricAlarms` en appelant [DescribeAlarmsResult](https://docs.aws.amazon.com/sdk-for-cpp/latest/api/aws-cpp-sdk-monitoring/html/class_aws_1_1_cloud_watch_1_1_model_1_1_describe_alarms_result.html)le code renvoyé par`DescribeAlarms`.

Les résultats peuvent être *paginés*. Pour récupérer le lot de résultats suivant, appelez `SetNextToken` l'objet de demande d'origine avec la valeur de retour de la `GetNextToken` fonction de l'`DescribeAlarmsResult`objet et retransmettez l'objet de demande modifié à un autre appel à`DescribeAlarms`.

**Note**  
Vous pouvez également récupérer les alarmes pour une métrique spécifique à l'aide CloudWatchClient de la `DescribeAlarmsForMetric` fonction « s ». Son utilisation est similaire à `DescribeAlarms`.

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

## Suppression d'alarmes
<a name="delete-alarms"></a>

Pour supprimer des CloudWatch alarmes, appelez la `DeleteAlarms` fonction CloudWatchClient's [DeleteAlarmsRequest](https://docs.aws.amazon.com/sdk-for-cpp/latest/api/aws-cpp-sdk-monitoring/html/class_aws_1_1_cloud_watch_1_1_model_1_1_delete_alarms_request.html)contenant un ou plusieurs noms d'alarmes que vous souhaitez supprimer.

 **Comprend** 

```
#include <aws/core/Aws.h>
#include <aws/monitoring/CloudWatchClient.h>
#include <aws/monitoring/model/DeleteAlarmsRequest.h>
#include <iostream>
```

 **Code** 

```
        Aws::CloudWatch::CloudWatchClient cw;
        Aws::CloudWatch::Model::DeleteAlarmsRequest request;
        request.AddAlarmNames(alarm_name);

        auto outcome = cw.DeleteAlarms(request);
        if (!outcome.IsSuccess())
        {
            std::cout << "Failed to delete CloudWatch alarm:" <<
                outcome.GetError().GetMessage() << std::endl;
        }
        else
        {
            std::cout << "Successfully deleted CloudWatch alarm " << alarm_name
                << std::endl;
        }
```

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

## En savoir plus
<a name="more-information"></a>
+  [Création d' CloudWatch alarmes Amazon](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/AlarmThatSendsEmail.html) dans le guide de CloudWatch l'utilisateur Amazon
+  [PutMetricAlarm](https://docs.aws.amazon.com/AmazonCloudWatch/latest/APIReference/PutMetricAlarm.html)dans le Amazon CloudWatch API Reference
+  [DescribeAlarms](https://docs.aws.amazon.com/AmazonCloudWatch/latest/APIReference/DescribeAlarms.html)dans le Amazon CloudWatch API Reference
+  [DeleteAlarms](https://docs.aws.amazon.com/AmazonCloudWatch/latest/APIReference/DeleteAlarms.html)dans le Amazon CloudWatch API Reference

# Utilisation des actions d'alarme dans CloudWatch
<a name="examples-cloudwatch-use-alarm-actions"></a>

À l'aide CloudWatch d'actions d'alarme, vous pouvez créer des alarmes qui exécutent des actions telles que l'arrêt automatique, la résiliation, le redémarrage ou la restauration d'instances Amazon EC2.

Des actions d'alarme peuvent être ajoutées à une alarme en utilisant la `SetAlarmActions` fonction « s » lors [PutMetricAlarmRequest](https://docs.aws.amazon.com/sdk-for-cpp/latest/api/aws-cpp-sdk-monitoring/html/class_aws_1_1_cloud_watch_1_1_model_1_1_put_metric_alarm_request.html)de la [création d'une alarme](examples-cloudwatch-create-alarms.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).

## Activation d'actions d'alarme
<a name="enable-alarm-actions"></a>

Pour activer les actions d' CloudWatch alarme pour une alarme, appelez les CloudWatchClient s `EnableAlarmActions` avec [EnableAlarmActionsRequest](https://docs.aws.amazon.com/sdk-for-cpp/latest/api/aws-cpp-sdk-monitoring/html/class_aws_1_1_cloud_watch_1_1_model_1_1_enable_alarm_actions_request.html)un ou plusieurs noms d'alarmes dont vous souhaitez activer les actions.

 **Comprend** 

```
#include <aws/core/Aws.h>
#include <aws/monitoring/CloudWatchClient.h>
#include <aws/monitoring/model/EnableAlarmActionsRequest.h>
#include <aws/monitoring/model/PutMetricAlarmRequest.h>
#include <iostream>
```

 **Code** 

```
    Aws::CloudWatch::CloudWatchClient cw;
    Aws::CloudWatch::Model::PutMetricAlarmRequest request;
    request.SetAlarmName(alarm_name);
    request.SetComparisonOperator(
        Aws::CloudWatch::Model::ComparisonOperator::GreaterThanThreshold);
    request.SetEvaluationPeriods(1);
    request.SetMetricName("CPUUtilization");
    request.SetNamespace("AWS/EC2");
    request.SetPeriod(60);
    request.SetStatistic(Aws::CloudWatch::Model::Statistic::Average);
    request.SetThreshold(70.0);
    request.SetActionsEnabled(false);
    request.SetAlarmDescription("Alarm when server CPU exceeds 70%");
    request.SetUnit(Aws::CloudWatch::Model::StandardUnit::Seconds);
    request.AddAlarmActions(actionArn);

    Aws::CloudWatch::Model::Dimension dimension;
    dimension.SetName("InstanceId");
    dimension.SetValue(instanceId);
    request.AddDimensions(dimension);

    auto outcome = cw.PutMetricAlarm(request);
    if (!outcome.IsSuccess())
    {
        std::cout << "Failed to create CloudWatch alarm:" <<
            outcome.GetError().GetMessage() << std::endl;
        return;
    }

    Aws::CloudWatch::Model::EnableAlarmActionsRequest enable_request;
    enable_request.AddAlarmNames(alarm_name);

    auto enable_outcome = cw.EnableAlarmActions(enable_request);
    if (!enable_outcome.IsSuccess())
    {
        std::cout << "Failed to enable alarm actions:" <<
            enable_outcome.GetError().GetMessage() << std::endl;
        return;
    }

    std::cout << "Successfully created alarm " << alarm_name <<
        " and enabled actions on it." << std::endl;
```

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

## Désactivation d'actions d'alarme
<a name="disable-alarm-actions"></a>

Pour désactiver les actions d' CloudWatch alarme associées à une alarme, appelez le CloudWatchClient s [DisableAlarmActionsRequest](https://docs.aws.amazon.com/sdk-for-cpp/latest/api/aws-cpp-sdk-monitoring/html/class_aws_1_1_cloud_watch_1_1_model_1_1_disable_alarm_actions_request.html)contenant un ou plusieurs noms d'alarmes dont vous souhaitez désactiver les actions. `DisableAlarmActions`

 **Comprend** 

```
#include <aws/core/Aws.h>
#include <aws/monitoring/CloudWatchClient.h>
#include <aws/monitoring/model/DisableAlarmActionsRequest.h>
#include <iostream>
```

 **Code** 

```
        Aws::CloudWatch::CloudWatchClient cw;

        Aws::CloudWatch::Model::DisableAlarmActionsRequest disableAlarmActionsRequest;
        disableAlarmActionsRequest.AddAlarmNames(alarm_name);

        auto disableAlarmActionsOutcome = cw.DisableAlarmActions(disableAlarmActionsRequest);
        if (!disableAlarmActionsOutcome.IsSuccess())
        {
            std::cout << "Failed to disable actions for alarm " << alarm_name <<
                ": " << disableAlarmActionsOutcome.GetError().GetMessage() <<
                std::endl;
        }
        else
        {
            std::cout << "Successfully disabled actions for alarm " <<
                alarm_name << std::endl;
        }
```

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

## En savoir plus
<a name="more-information"></a>
+  [Créez des alarmes pour arrêter, mettre fin, redémarrer ou récupérer une instance](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/UsingAlarmActions.html) dans le guide de CloudWatch l'utilisateur Amazon
+  [PutMetricAlarm](https://docs.aws.amazon.com/AmazonCloudWatch/latest/APIReference/PutMetricAlarm.html)dans le Amazon CloudWatch API Reference
+  [EnableAlarmActions](https://docs.aws.amazon.com/AmazonCloudWatch/latest/APIReference/EnableAlarmActions.html)dans le Amazon CloudWatch API Reference
+  [DisableAlarmActions](https://docs.aws.amazon.com/AmazonCloudWatch/latest/APIReference/DisableAlarmActions.html)dans le Amazon CloudWatch API Reference

# Envoi d'événements à CloudWatch
<a name="examples-cloudwatch-send-events"></a>

CloudWatch Events fournit un flux d'événements système en temps quasi réel décrivant les modifications apportées aux AWS ressources des instances Amazon EC2, des fonctions Lambda, des flux Kinesis, des tâches Amazon ECS, des machines d'état Step Functions, des rubriques Amazon SNS, des files d'attente Amazon SQS ou des cibles intégrées. À l'aide de règles simples, vous pouvez faire correspondre les événements et les acheminer vers un ou plusieurs flux ou fonctions cibles.

**Note**  
Ces extraits de code supposent que vous comprenez le contenu de [Getting Started Using the AWS SDK pour C\$1\$1 et que vous avez configuré les](getting-started.md) informations d' AWS identification par défaut à l'aide des informations contenues dans [Fournir AWS](credentials.md) des informations d'identification.

## Ajout d'événements
<a name="add-events"></a>

Pour ajouter CloudWatch des événements personnalisés, appelez la `PutEvents` fonction CloudWatchEventsClient's avec un [PutEventsRequest](https://docs.aws.amazon.com/sdk-for-cpp/latest/api/aws-cpp-sdk-eventbridge/html/class_aws_1_1_event_bridge_1_1_model_1_1_put_events_request.html)objet contenant un ou plusieurs [PutEventsRequestEntry](https://docs.aws.amazon.com/sdk-for-cpp/latest/api/aws-cpp-sdk-eventbridge/html/class_aws_1_1_event_bridge_1_1_model_1_1_put_events_request_entry.html)objets fournissant des détails sur chaque événement. Vous pouvez spécifier plusieurs paramètres pour l'entrée, tels que la source et le type de l'événement, les ressources associées à l'événement, et ainsi de suite.

**Note**  
Vous pouvez spécifier un maximum de 10 événements par appel de `putEvents`.

 **Comprend** 

```
#include <aws/core/Aws.h>
#include <aws/events/EventBridgeClient.h>
#include <aws/events/model/PutEventsRequest.h>
#include <aws/events/model/PutEventsResult.h>
#include <aws/core/utils/Outcome.h>
#include <iostream>
```

 **Code** 

```
        Aws::CloudWatchEvents::EventBridgeClient cwe;

        Aws::CloudWatchEvents::Model::PutEventsRequestEntry event_entry;
        event_entry.SetDetail(MakeDetails(event_key, event_value));
        event_entry.SetDetailType("sampleSubmitted");
        event_entry.AddResources(resource_arn);
        event_entry.SetSource("aws-sdk-cpp-cloudwatch-example");

        Aws::CloudWatchEvents::Model::PutEventsRequest request;
        request.AddEntries(event_entry);

        auto outcome = cwe.PutEvents(request);
        if (!outcome.IsSuccess())
        {
            std::cout << "Failed to post CloudWatch event: " <<
                outcome.GetError().GetMessage() << std::endl;
        }
        else
        {
            std::cout << "Successfully posted CloudWatch event" << std::endl;
        }
```

## Ajout de règles
<a name="add-rules"></a>

Pour créer ou mettre à jour une règle, appelez la `PutRule` fonction CloudWatchEventsClient's [PutRuleRequest](https://docs.aws.amazon.com/sdk-for-cpp/latest/api/aws-cpp-sdk-eventbridge/html/class_aws_1_1_event_bridge_1_1_model_1_1_put_rule_request.html)avec le nom de la règle et des paramètres facultatifs tels que le [modèle d'événement](https://docs.aws.amazon.com/AmazonCloudWatch/latest/events/CloudWatchEventsandEventPatterns.html), le rôle IAM à associer à la règle et une [expression de planification](https://docs.aws.amazon.com/AmazonCloudWatch/latest/events/ScheduledEvents.html) décrivant la fréquence d'exécution de la règle.

 **Comprend** 

```
#include <aws/core/Aws.h>
#include <aws/events/EventBridgeClient.h>
#include <aws/events/model/PutRuleRequest.h>
#include <aws/events/model/PutRuleResult.h>
#include <aws/core/utils/Outcome.h>
#include <iostream>
```

 **Code** 

```
        Aws::CloudWatchEvents::EventBridgeClient cwe;
        Aws::CloudWatchEvents::Model::PutRuleRequest request;
        request.SetName(rule_name);
        request.SetRoleArn(role_arn);
        request.SetScheduleExpression("rate(5 minutes)");
        request.SetState(Aws::CloudWatchEvents::Model::RuleState::ENABLED);

        auto outcome = cwe.PutRule(request);
        if (!outcome.IsSuccess())
        {
            std::cout << "Failed to create CloudWatch events rule " <<
                rule_name << ": " << outcome.GetError().GetMessage() <<
                std::endl;
        }
        else
        {
            std::cout << "Successfully created CloudWatch events rule " <<
                rule_name << " with resulting Arn " <<
                outcome.GetResult().GetRuleArn() << std::endl;
        }
```

## Ajout de cibles
<a name="add-targets"></a>

Les cibles sont les ressources appelées lorsqu'une règle est déclenchée. Les exemples de cibles incluent les instances Amazon EC2, les fonctions Lambda, les flux Kinesis, les tâches Amazon ECS, les machines d'état Step Functions et les cibles intégrées.

Pour ajouter une cible à une règle, appelez la `PutTargets` fonction CloudWatchEventsClient's avec un [PutTargetsRequest](https://docs.aws.amazon.com/sdk-for-cpp/latest/api/aws-cpp-sdk-eventbridge/html/class_aws_1_1_event_bridge_1_1_model_1_1_put_targets_request.html)contenant la règle à mettre à jour et une liste de cibles à ajouter à la règle.

 **Comprend** 

```
#include <aws/core/Aws.h>
#include <aws/events/EventBridgeClient.h>
#include <aws/events/model/PutTargetsRequest.h>
#include <aws/events/model/PutTargetsResult.h>
#include <aws/core/utils/Outcome.h>
#include <iostream>
```

 **Code** 

```
        Aws::CloudWatchEvents::EventBridgeClient cwe;

        Aws::CloudWatchEvents::Model::Target target;
        target.SetArn(lambda_arn);
        target.SetId(target_id);

        Aws::CloudWatchEvents::Model::PutTargetsRequest request;
        request.SetRule(rule_name);
        request.AddTargets(target);

        auto putTargetsOutcome = cwe.PutTargets(request);
        if (!putTargetsOutcome.IsSuccess())
        {
            std::cout << "Failed to create CloudWatch events target for rule "
                << rule_name << ": " <<
                putTargetsOutcome.GetError().GetMessage() << std::endl;
        }
        else
        {
            std::cout <<
                "Successfully created CloudWatch events target for rule "
                << rule_name << std::endl;
        }
```

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

## En savoir plus
<a name="more-information"></a>
+  [Ajouter des événements PutEvents](https://docs.aws.amazon.com/AmazonCloudWatch/latest/events/AddEventsPutEvents.html) dans le guide de l'utilisateur d'Amazon CloudWatch Events
+  [Expressions de planification pour les règles](https://docs.aws.amazon.com/AmazonCloudWatch/latest/events/ScheduledEvents.html) dans le guide de l'utilisateur d'Amazon CloudWatch Events
+  [Types d'événements pour les CloudWatch événements figurant](https://docs.aws.amazon.com/AmazonCloudWatch/latest/events/EventTypes.html) dans le guide de l'utilisateur d'Amazon CloudWatch Events
+  [Événements et modèles d'événements](https://docs.aws.amazon.com/AmazonCloudWatch/latest/events/CloudWatchEventsandEventPatterns.html) dans le guide de l'utilisateur d'Amazon CloudWatch Events
+  [PutEvents](https://docs.aws.amazon.com/AmazonCloudWatchEvents/latest/APIReference/PutEvents.html)dans la référence de l'API Amazon CloudWatch Events
+  [PutTargets](https://docs.aws.amazon.com/AmazonCloudWatchEvents/latest/APIReference/PutTargets.html)dans la référence de l'API Amazon CloudWatch Events
+  [PutRule](https://docs.aws.amazon.com/AmazonCloudWatchEvents/latest/APIReference/PutRule.html)dans la référence de l'API Amazon CloudWatch Events

# Exemples d'Amazon DynamoDB utilisant le AWS SDK pour C\$1\$1
<a name="examples-dynamodb"></a>

Amazon DynamoDB est un service de base de données NoSQL entièrement géré, offrant des performances exceptionnelles et prévisibles en termes de rapidité et d’évolutivité. Les exemples suivants montrent comment programmer [Amazon DynamoDB](https://aws.amazon.com/dynamodb) à l'aide du. AWS SDK pour C\$1\$1

**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.

**Topics**
+ [Utilisation de tables dans DynamoDB](examples-dynamodb-tables.md)
+ [Utilisation d'éléments dans DynamoDB](examples-dynamodb-items.md)

# Utilisation de tables dans DynamoDB
<a name="examples-dynamodb-tables"></a>

Les tables sont les conteneurs de tous les éléments d'une base de données DynamoDB. Avant de pouvoir ajouter ou supprimer des données dans DynamoDB, vous devez créer une table.

Pour chaque table, vous devez définir :
+ *Nom* de table unique pour votre Compte AWS et Région AWS.
+ Une *clé primaire* pour laquelle chaque valeur doit être unique. Deux éléments de votre tableau ne peuvent pas avoir la même valeur de clé primaire.

  Une clé primaire peut être *simple*, constituée d'une seule clé de partition (HASH) ou *composite*, constituée d'une partition et d'une clé de tri (RANGE).

  Chaque valeur clé est associée à un *type de données*, énuméré par la [ScalarAttributeType](https://docs.aws.amazon.com/sdk-for-cpp/latest/api/aws-cpp-sdk-dynamodb/html/namespace_aws_1_1_dynamo_d_b_1_1_model.html#a4b39ae66214e022d3737079d071e4bcb.html)classe. La valeur de la clé peut être binaire (B), numérique (N) ou de type chaîne (S). Pour plus d'informations, consultez la section [Règles de dénomination et types de données](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/HowItWorks.NamingRulesDataTypes.html) dans le manuel du développeur Amazon DynamoDB.
+  Valeurs de *débit provisionnées* qui définissent le nombre d'unités de read/write capacité réservées pour la table.
**Note**  
 La [tarification d'Amazon DynamoDB](https://aws.amazon.com/dynamodb/pricing/) repose sur les valeurs de débit alloué que vous définissez sur vos tables. Veillez donc à ne réserver que la capacité dont vous pensez avoir besoin pour votre table.  
Le débit alloué pour une table peut être modifié à tout moment pour que vous puissiez ajuster la capacité si vos besoins évoluent.

## Création d’une table
<a name="dynamodb-create-table"></a>

Utilisez la méthode `CreateTable` client [DynamoDB pour créer](https://docs.aws.amazon.com/sdk-for-cpp/latest/api/aws-cpp-sdk-dynamodb/html/class_aws_1_1_dynamo_d_b_1_1_dynamo_d_b_client.html) une nouvelle table DynamoDB. Vous devez créer des attributs de table et un schéma de table qui sont utilisés pour identifier la clé primaire de votre table. Vous devez également fournir des valeurs de débit provisionnées initiales et un nom de table. `CreateTable`est une opération asynchrone. `GetTableStatus`renverra CREATING jusqu'à ce que la table soit ACTIVE et prête à être utilisée.

### Création d'une table avec une clé primaire simple
<a name="dynamodb-create-table-simple"></a>

Ce code crée une table avec une clé primaire simple ("Name").

 **Comprend** 

```
#include <aws/core/Aws.h>
#include <aws/dynamodb/DynamoDBClient.h>
#include <aws/dynamodb/model/AttributeDefinition.h>
#include <aws/dynamodb/model/CreateTableRequest.h>
#include <aws/dynamodb/model/KeySchemaElement.h>
#include <aws/dynamodb/model/ProvisionedThroughput.h>
#include <aws/dynamodb/model/ScalarAttributeType.h>
#include <iostream>
```

 **Code** 

```
//! Create an Amazon DynamoDB table.
/*!
  \sa createTable()
  \param tableName: Name for the DynamoDB table.
  \param primaryKey: Primary key for the DynamoDB table.
  \param clientConfiguration: AWS client configuration.
  \return bool: Function succeeded.
 */
bool AwsDoc::DynamoDB::createTable(const Aws::String &tableName,
                                   const Aws::String &primaryKey,
                                   const Aws::Client::ClientConfiguration &clientConfiguration) {
    Aws::DynamoDB::DynamoDBClient dynamoClient(clientConfiguration);

    std::cout << "Creating table " << tableName <<
              " with a simple primary key: \"" << primaryKey << "\"." << std::endl;

    Aws::DynamoDB::Model::CreateTableRequest request;

    Aws::DynamoDB::Model::AttributeDefinition hashKey;
    hashKey.SetAttributeName(primaryKey);
    hashKey.SetAttributeType(Aws::DynamoDB::Model::ScalarAttributeType::S);
    request.AddAttributeDefinitions(hashKey);

    Aws::DynamoDB::Model::KeySchemaElement keySchemaElement;
    keySchemaElement.WithAttributeName(primaryKey).WithKeyType(
            Aws::DynamoDB::Model::KeyType::HASH);
    request.AddKeySchema(keySchemaElement);

    Aws::DynamoDB::Model::ProvisionedThroughput throughput;
    throughput.WithReadCapacityUnits(5).WithWriteCapacityUnits(5);
    request.SetProvisionedThroughput(throughput);
    request.SetTableName(tableName);

    const Aws::DynamoDB::Model::CreateTableOutcome &outcome = dynamoClient.CreateTable(
            request);
    if (outcome.IsSuccess()) {
        std::cout << "Table \""
                  << outcome.GetResult().GetTableDescription().GetTableName() <<
                  " created!" << std::endl;
    }
    else {
        std::cerr << "Failed to create table: " << outcome.GetError().GetMessage()
                  << std::endl;
        return false;
    }

    return waitTableActive(tableName, dynamoClient);
}
```

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

### Création d'une table avec une clé primaire composite
<a name="dynamodb-create-table-composite"></a>

Ajoutez-en un autre [AttributeDefinition](https://docs.aws.amazon.com/sdk-for-cpp/latest/api/aws-cpp-sdk-dynamodb/html/class_aws_1_1_dynamo_d_b_1_1_model_1_1_attribute_definition.html)et [KeySchemaElement](https://docs.aws.amazon.com/sdk-for-cpp/latest/api/aws-cpp-sdk-dynamodb/html/class_aws_1_1_dynamo_d_b_1_1_model_1_1_key_schema_element.html)à [CreateTableRequest](https://docs.aws.amazon.com/sdk-for-cpp/latest/api/aws-cpp-sdk-dynamodb/html/class_aws_1_1_dynamo_d_b_1_1_model_1_1_create_table_request.html).

 **Comprend** 

```
#include <aws/core/Aws.h>
#include <aws/dynamodb/DynamoDBClient.h>
#include <aws/dynamodb/model/AttributeDefinition.h>
#include <aws/dynamodb/model/CreateTableRequest.h>
#include <aws/dynamodb/model/KeySchemaElement.h>
#include <aws/dynamodb/model/ProvisionedThroughput.h>
#include <aws/dynamodb/model/ScalarAttributeType.h>
#include <iostream>
```

 **Code** 

```
//! Create an Amazon DynamoDB table with a composite key.
/*!
  \sa createTableWithCompositeKey()
  \param tableName: Name for the DynamoDB table.
  \param partitionKey: Name for the partition (hash) key.
  \param sortKey: Name for the sort (range) key.
  \param clientConfiguration: AWS client configuration.
  \return bool: Function succeeded.
 */
bool AwsDoc::DynamoDB::createTableWithCompositeKey(const Aws::String &tableName,
                                                   const Aws::String &partitionKey,
                                                   const Aws::String &sortKey,
                                                   const Aws::Client::ClientConfiguration &clientConfiguration) {
    Aws::DynamoDB::DynamoDBClient dynamoClient(clientConfiguration);

    std::cout << "Creating table " << tableName <<
              " with a composite primary key:\n" \
            "* " << partitionKey << " - partition key\n" \
            "* " << sortKey << " - sort key\n";

    Aws::DynamoDB::Model::CreateTableRequest request;

    Aws::DynamoDB::Model::AttributeDefinition hashKey1, hashKey2;
    hashKey1.WithAttributeName(partitionKey).WithAttributeType(
            Aws::DynamoDB::Model::ScalarAttributeType::S);
    request.AddAttributeDefinitions(hashKey1);
    hashKey2.WithAttributeName(sortKey).WithAttributeType(
            Aws::DynamoDB::Model::ScalarAttributeType::S);
    request.AddAttributeDefinitions(hashKey2);

    Aws::DynamoDB::Model::KeySchemaElement keySchemaElement1, keySchemaElement2;
    keySchemaElement1.WithAttributeName(partitionKey).WithKeyType(
            Aws::DynamoDB::Model::KeyType::HASH);
    request.AddKeySchema(keySchemaElement1);
    keySchemaElement2.WithAttributeName(sortKey).WithKeyType(
            Aws::DynamoDB::Model::KeyType::RANGE);
    request.AddKeySchema(keySchemaElement2);

    Aws::DynamoDB::Model::ProvisionedThroughput throughput;
    throughput.WithReadCapacityUnits(5).WithWriteCapacityUnits(5);
    request.SetProvisionedThroughput(throughput);

    request.SetTableName(tableName);

    const Aws::DynamoDB::Model::CreateTableOutcome &outcome = dynamoClient.CreateTable(
            request);
    if (outcome.IsSuccess()) {
        std::cout << "Table \""
                  << outcome.GetResult().GetTableDescription().GetTableName() <<
                  "\" was created!" << std::endl;
    }
    else {
        std::cerr << "Failed to create table:" << outcome.GetError().GetMessage()
                  << std::endl;
        return false;
    }

    return waitTableActive(tableName, dynamoClient);
}
```

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

## Affichage d'une liste de tables
<a name="dynamodb-list-tables"></a>

Vous pouvez répertorier les tables d'une région donnée en appelant la méthode [client `ListTables` DynamoDB](https://docs.aws.amazon.com/sdk-for-cpp/latest/api/aws-cpp-sdk-dynamodb/html/class_aws_1_1_dynamo_d_b_1_1_dynamo_d_b_client.html).

 **Comprend** 

```
#include <aws/core/Aws.h>
#include <aws/core/utils/Outcome.h>
#include <aws/dynamodb/DynamoDBClient.h>
#include <aws/dynamodb/model/ListTablesRequest.h>
#include <aws/dynamodb/model/ListTablesResult.h>
#include <iostream>
```

 **Code** 

```
//! List the Amazon DynamoDB tables for the current AWS account.
/*!
  \sa listTables()
  \param clientConfiguration: AWS client configuration.
  \return bool: Function succeeded.
 */

bool AwsDoc::DynamoDB::listTables(
        const Aws::Client::ClientConfiguration &clientConfiguration) {
    Aws::DynamoDB::DynamoDBClient dynamoClient(clientConfiguration);

    Aws::DynamoDB::Model::ListTablesRequest listTablesRequest;
    listTablesRequest.SetLimit(50);
    do {
        const Aws::DynamoDB::Model::ListTablesOutcome &outcome = dynamoClient.ListTables(
                listTablesRequest);
        if (!outcome.IsSuccess()) {
            std::cout << "Error: " << outcome.GetError().GetMessage() << std::endl;
            return false;
        }

        for (const auto &tableName: outcome.GetResult().GetTableNames())
            std::cout << tableName << std::endl;
        listTablesRequest.SetExclusiveStartTableName(
                outcome.GetResult().GetLastEvaluatedTableName());

    } while (!listTablesRequest.GetExclusiveStartTableName().empty());

    return true;
}
```

Par défaut, jusqu'à 100 tables sont renvoyées par appel. `GetExclusiveStartTableName`À utiliser sur l'[ListTablesOutcome](https://docs.aws.amazon.com/sdk-for-cpp/latest/api/aws-cpp-sdk-dynamodb/html/class_aws_1_1_dynamo_d_b_1_1_dynamo_d_b_client.html)objet renvoyé pour obtenir la dernière table évaluée. Vous pouvez utiliser cette valeur pour démarrer la liste après la dernière valeur renvoyée de la liste précédente.

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

## Récupérer les informations relatives à une table
<a name="dynamodb-describe-table"></a>

Pour en savoir plus sur une table, appelez la méthode client [`DescribeTable`DynamoDB](https://docs.aws.amazon.com/sdk-for-cpp/latest/api/aws-cpp-sdk-dynamodb/html/class_aws_1_1_dynamo_d_b_1_1_dynamo_d_b_client.html).

 **Comprend** 

```
#include <aws/core/Aws.h>
#include <aws/dynamodb/DynamoDBClient.h>
#include <aws/dynamodb/model/DescribeTableRequest.h>
#include <iostream>
```

 **Code** 

```
//! Describe an Amazon DynamoDB table.
/*!
  \sa describeTable()
  \param tableName: The DynamoDB table name.
  \param clientConfiguration: AWS client configuration.
  \return bool: Function succeeded.
*/
bool AwsDoc::DynamoDB::describeTable(const Aws::String &tableName,
                                     const Aws::Client::ClientConfiguration &clientConfiguration) {
    Aws::DynamoDB::DynamoDBClient dynamoClient(clientConfiguration);

    Aws::DynamoDB::Model::DescribeTableRequest request;
    request.SetTableName(tableName);

    const Aws::DynamoDB::Model::DescribeTableOutcome &outcome = dynamoClient.DescribeTable(
            request);

    if (outcome.IsSuccess()) {
        const Aws::DynamoDB::Model::TableDescription &td = outcome.GetResult().GetTable();
        std::cout << "Table name  : " << td.GetTableName() << std::endl;
        std::cout << "Table ARN   : " << td.GetTableArn() << std::endl;
        std::cout << "Status      : "
                  << Aws::DynamoDB::Model::TableStatusMapper::GetNameForTableStatus(
                          td.GetTableStatus()) << std::endl;
        std::cout << "Item count  : " << td.GetItemCount() << std::endl;
        std::cout << "Size (bytes): " << td.GetTableSizeBytes() << std::endl;

        const Aws::DynamoDB::Model::ProvisionedThroughputDescription &ptd = td.GetProvisionedThroughput();
        std::cout << "Throughput" << std::endl;
        std::cout << "  Read Capacity : " << ptd.GetReadCapacityUnits() << std::endl;
        std::cout << "  Write Capacity: " << ptd.GetWriteCapacityUnits() << std::endl;

        const Aws::Vector<Aws::DynamoDB::Model::AttributeDefinition> &ad = td.GetAttributeDefinitions();
        std::cout << "Attributes" << std::endl;
        for (const auto &a: ad)
            std::cout << "  " << a.GetAttributeName() << " (" <<
                      Aws::DynamoDB::Model::ScalarAttributeTypeMapper::GetNameForScalarAttributeType(
                              a.GetAttributeType()) <<
                      ")" << std::endl;
    }
    else {
        std::cerr << "Failed to describe table: " << outcome.GetError().GetMessage();
    }

    return outcome.IsSuccess();
}
```

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

## Modifier un tableau
<a name="dynamodb-update-table"></a>

[Vous pouvez modifier les valeurs de débit provisionnées de votre table à tout moment en appelant la méthode client DynamoDB.](https://docs.aws.amazon.com/sdk-for-cpp/latest/api/aws-cpp-sdk-dynamodb/html/class_aws_1_1_dynamo_d_b_1_1_dynamo_d_b_client.html) `UpdateTable`

 **Comprend** 

```
#include <aws/core/Aws.h>
#include <aws/core/utils/Outcome.h>
#include <aws/dynamodb/DynamoDBClient.h>
#include <aws/dynamodb/model/ProvisionedThroughput.h>
#include <aws/dynamodb/model/UpdateTableRequest.h>
#include <iostream>
```

 **Code** 

```
//! Update a DynamoDB table.
/*!
  \sa updateTable()
  \param tableName: Name for the DynamoDB table.
  \param readCapacity: Provisioned read capacity.
  \param writeCapacity: Provisioned write capacity.
  \param clientConfiguration: AWS client configuration.
  \return bool: Function succeeded.
 */
bool AwsDoc::DynamoDB::updateTable(const Aws::String &tableName,
                                   long long readCapacity, long long writeCapacity,
                                   const Aws::Client::ClientConfiguration &clientConfiguration) {
    Aws::DynamoDB::DynamoDBClient dynamoClient(clientConfiguration);

    std::cout << "Updating " << tableName << " with new provisioned throughput values"
              << std::endl;
    std::cout << "Read capacity : " << readCapacity << std::endl;
    std::cout << "Write capacity: " << writeCapacity << std::endl;

    Aws::DynamoDB::Model::UpdateTableRequest request;
    Aws::DynamoDB::Model::ProvisionedThroughput provisionedThroughput;
    provisionedThroughput.WithReadCapacityUnits(readCapacity).WithWriteCapacityUnits(
            writeCapacity);
    request.WithProvisionedThroughput(provisionedThroughput).WithTableName(tableName);

    const Aws::DynamoDB::Model::UpdateTableOutcome &outcome = dynamoClient.UpdateTable(
            request);
    if (outcome.IsSuccess()) {
        std::cout << "Successfully updated the table." << std::endl;
    } else {
        const Aws::DynamoDB::DynamoDBError &error = outcome.GetError();
        if (error.GetErrorType() == Aws::DynamoDB::DynamoDBErrors::VALIDATION &&
            error.GetMessage().find("The provisioned throughput for the table will not change") != std::string::npos) {
            std::cout << "The provisioned throughput for the table will not change." << std::endl;
        } else {
            std::cerr << outcome.GetError().GetMessage() << std::endl;
            return false;
        }
    }

    return waitTableActive(tableName, dynamoClient);
}
```

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

## Suppression d'une table
<a name="dynamodb-delete-table"></a>

Appelez la méthode `DeleteTable` client [DynamoDB et transmettez-lui](https://docs.aws.amazon.com/sdk-for-cpp/latest/api/aws-cpp-sdk-dynamodb/html/class_aws_1_1_dynamo_d_b_1_1_dynamo_d_b_client.html) le nom de la table.

 **Comprend** 

```
#include <aws/core/Aws.h>
#include <aws/dynamodb/DynamoDBClient.h>
#include <aws/dynamodb/model/DeleteTableRequest.h>
#include <iostream>
```

 **Code** 

```
//! Delete an Amazon DynamoDB table.
/*!
  \sa deleteTable()
  \param tableName: The DynamoDB table name.
  \param clientConfiguration: AWS client configuration.
  \return bool: Function succeeded.
*/
bool AwsDoc::DynamoDB::deleteTable(const Aws::String &tableName,
                                   const Aws::Client::ClientConfiguration &clientConfiguration) {
    Aws::DynamoDB::DynamoDBClient dynamoClient(clientConfiguration);

    Aws::DynamoDB::Model::DeleteTableRequest request;
    request.SetTableName(tableName);

    const Aws::DynamoDB::Model::DeleteTableOutcome &result = dynamoClient.DeleteTable(
            request);
    if (result.IsSuccess()) {
        std::cout << "Your table \""
                  << result.GetResult().GetTableDescription().GetTableName()
                  << " was deleted.\n";
    }
    else {
        std::cerr << "Failed to delete table: " << result.GetError().GetMessage()
                  << std::endl;
    }

    return result.IsSuccess();
}
```

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

## Plus d'informations
<a name="more-info"></a>
+  [Instructions relatives à l'utilisation des tables](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/GuidelinesForTables.html) dans le guide du développeur Amazon DynamoDB
+  [Utilisation de tables dans DynamoDB dans](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/WorkingWithTables.html) le manuel du développeur Amazon DynamoDB

# Utilisation d'éléments dans DynamoDB
<a name="examples-dynamodb-items"></a>

*Dans DynamoDB, un élément est un ensemble *d'*attributs dont chacun possède *un nom et une valeur*.* Une valeur d'attribut peut être de type scalar, set ou document. Pour plus d'informations, consultez la section [Règles de dénomination et types de données](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/HowItWorks.NamingRulesDataTypes.html) dans le manuel du développeur Amazon DynamoDB.

## Récupérer un élément d'une table
<a name="dynamodb-get-item"></a>

Appelez la méthode [client `GetItem` DynamoDB](https://docs.aws.amazon.com/sdk-for-cpp/latest/api/aws-cpp-sdk-dynamodb/html/class_aws_1_1_dynamo_d_b_1_1_dynamo_d_b_client.html). Passez-lui un [GetItemRequest](https://docs.aws.amazon.com/sdk-for-cpp/latest/api/aws-cpp-sdk-dynamodb/html/class_aws_1_1_dynamo_d_b_1_1_model_1_1_get_item_request.html)objet avec le nom de la table et la valeur de la clé primaire de l'élément souhaité. Elle renvoie un [GetItemResult](https://docs.aws.amazon.com/sdk-for-cpp/latest/api/aws-cpp-sdk-dynamodb/html/class_aws_1_1_dynamo_d_b_1_1_model_1_1_get_item_result.html)objet.

Vous pouvez utiliser la `GetItem()` méthode de `GetItemResult` l'objet renvoyé pour récupérer une [AttributeValue](https://docs.aws.amazon.com/sdk-for-cpp/latest/api/aws-cpp-sdk-dynamodb/html/class_aws_1_1_dynamo_d_b_1_1_model_1_1_attribute_value.html)paire `Aws::Map` de clés `Aws::String` et de valeurs associées à l'élément.

 **Comprend** 

```
#include <aws/core/Aws.h>
#include <aws/dynamodb/DynamoDBClient.h>
#include <aws/dynamodb/model/AttributeDefinition.h>
#include <aws/dynamodb/model/GetItemRequest.h>
#include <iostream>
```

 **Code** 

```
//! Get an item from an Amazon DynamoDB table.
/*!
  \sa getItem()
  \param tableName: The table name.
  \param partitionKey: The partition key.
  \param partitionValue: The value for the partition key.
  \param clientConfiguration: AWS client configuration.
  \return bool: Function succeeded.
 */

bool AwsDoc::DynamoDB::getItem(const Aws::String &tableName,
                               const Aws::String &partitionKey,
                               const Aws::String &partitionValue,
                               const Aws::Client::ClientConfiguration &clientConfiguration) {
    Aws::DynamoDB::DynamoDBClient dynamoClient(clientConfiguration);
    Aws::DynamoDB::Model::GetItemRequest request;

    // Set up the request.
    request.SetTableName(tableName);
    request.AddKey(partitionKey,
                   Aws::DynamoDB::Model::AttributeValue().SetS(partitionValue));

    // Retrieve the item's fields and values.
    const Aws::DynamoDB::Model::GetItemOutcome &outcome = dynamoClient.GetItem(request);
    if (outcome.IsSuccess()) {
        // Reference the retrieved fields/values.
        const Aws::Map<Aws::String, Aws::DynamoDB::Model::AttributeValue> &item = outcome.GetResult().GetItem();
        if (!item.empty()) {
            // Output each retrieved field and its value.
            for (const auto &i: item)
                std::cout << "Values: " << i.first << ": " << i.second.GetS()
                          << std::endl;
        }
        else {
            std::cout << "No item found with the key " << partitionKey << std::endl;
        }
    }
    else {
        std::cerr << "Failed to get item: " << outcome.GetError().GetMessage();
    }

    return outcome.IsSuccess();
}
```

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

## Ajouter un élément à un tableau
<a name="dynamodb-add-item"></a>

Créez des [AttributeValue](https://docs.aws.amazon.com/sdk-for-cpp/latest/api/aws-cpp-sdk-dynamodb/html/class_aws_1_1_dynamo_d_b_1_1_model_1_1_attribute_value.html)paires `Aws::String` de clés et de valeurs qui représentent chaque élément. Elles doivent inclure les valeurs des champs de clé primaire de la table. Si l'élément identifié par la clé primaire existe déjà, ses champs sont *mis à jour* par la demande. Ajoutez-les à l'[PutItemRequest](https://docs.aws.amazon.com/sdk-for-cpp/latest/api/aws-cpp-sdk-dynamodb/html/class_aws_1_1_dynamo_d_b_1_1_model_1_1_put_item_request.html)aide de la `AddItem` méthode.

 **Comprend** 

```
#include <aws/core/Aws.h>
#include <aws/dynamodb/DynamoDBClient.h>
#include <aws/dynamodb/model/AttributeDefinition.h>
#include <aws/dynamodb/model/PutItemRequest.h>
#include <aws/dynamodb/model/PutItemResult.h>
#include <iostream>
```

 **Code** 

```
//! Put an item in an Amazon DynamoDB table.
/*!
  \sa putItem()
  \param tableName: The table name.
  \param artistKey: The artist key. This is the partition key for the table.
  \param artistValue: The artist value.
  \param albumTitleKey: The album title key.
  \param albumTitleValue: The album title value.
  \param awardsKey: The awards key.
  \param awardsValue: The awards value.
  \param songTitleKey: The song title key.
  \param songTitleValue: The song title value.
  \param clientConfiguration: AWS client configuration.
  \return bool: Function succeeded.
 */
bool AwsDoc::DynamoDB::putItem(const Aws::String &tableName,
                               const Aws::String &artistKey,
                               const Aws::String &artistValue,
                               const Aws::String &albumTitleKey,
                               const Aws::String &albumTitleValue,
                               const Aws::String &awardsKey,
                               const Aws::String &awardsValue,
                               const Aws::String &songTitleKey,
                               const Aws::String &songTitleValue,
                               const Aws::Client::ClientConfiguration &clientConfiguration) {
    Aws::DynamoDB::DynamoDBClient dynamoClient(clientConfiguration);

    Aws::DynamoDB::Model::PutItemRequest putItemRequest;
    putItemRequest.SetTableName(tableName);

    putItemRequest.AddItem(artistKey, Aws::DynamoDB::Model::AttributeValue().SetS(
            artistValue)); // This is the hash key.
    putItemRequest.AddItem(albumTitleKey, Aws::DynamoDB::Model::AttributeValue().SetS(
            albumTitleValue));
    putItemRequest.AddItem(awardsKey,
                           Aws::DynamoDB::Model::AttributeValue().SetS(awardsValue));
    putItemRequest.AddItem(songTitleKey,
                           Aws::DynamoDB::Model::AttributeValue().SetS(songTitleValue));

    const Aws::DynamoDB::Model::PutItemOutcome outcome = dynamoClient.PutItem(
            putItemRequest);
    if (outcome.IsSuccess()) {
        std::cout << "Successfully added Item!" << std::endl;
    }
    else {
        std::cerr << outcome.GetError().GetMessage() << std::endl;
        return false;
    }

    return waitTableActive(tableName, dynamoClient);
}
```

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

## Mise à jour d'un élément existant dans une table
<a name="dynamodb-update-item"></a>

Vous pouvez mettre à jour un attribut pour un élément qui existe déjà dans une table en utilisant la `UpdateItem` méthode Dynamo, en fournissant le nom DBClient de la table, la valeur de la clé primaire, les champs à mettre à jour et leur valeur correspondante.

 **Importations** 

```
#include <aws/core/Aws.h>
#include <aws/dynamodb/DynamoDBClient.h>
#include <aws/dynamodb/model/UpdateItemRequest.h>
#include <aws/dynamodb/model/UpdateItemResult.h>
#include <iostream>
```

 **Code** 

```
//! Update an Amazon DynamoDB table item.
/*!
  \sa updateItem()
  \param tableName: The table name.
  \param partitionKey: The partition key.
  \param partitionValue: The value for the partition key.
  \param attributeKey: The key for the attribute to be updated.
  \param attributeValue: The value for the attribute to be updated.
  \param clientConfiguration: AWS client configuration.
  \return bool: Function succeeded.
  */

/*
 *  The example code only sets/updates an attribute value. It processes
 *  the attribute value as a string, even if the value could be interpreted
 *  as a number. Also, the example code does not remove an existing attribute
 *  from the key value.
 */

bool AwsDoc::DynamoDB::updateItem(const Aws::String &tableName,
                                  const Aws::String &partitionKey,
                                  const Aws::String &partitionValue,
                                  const Aws::String &attributeKey,
                                  const Aws::String &attributeValue,
                                  const Aws::Client::ClientConfiguration &clientConfiguration) {
    Aws::DynamoDB::DynamoDBClient dynamoClient(clientConfiguration);

    // *** Define UpdateItem request arguments.
    // Define TableName argument.
    Aws::DynamoDB::Model::UpdateItemRequest request;
    request.SetTableName(tableName);

    // Define KeyName argument.
    Aws::DynamoDB::Model::AttributeValue attribValue;
    attribValue.SetS(partitionValue);
    request.AddKey(partitionKey, attribValue);

    // Construct the SET update expression argument.
    Aws::String update_expression("SET #a = :valueA");
    request.SetUpdateExpression(update_expression);

    // Construct attribute name argument.
    Aws::Map<Aws::String, Aws::String> expressionAttributeNames;
    expressionAttributeNames["#a"] = attributeKey;
    request.SetExpressionAttributeNames(expressionAttributeNames);

    // Construct attribute value argument.
    Aws::DynamoDB::Model::AttributeValue attributeUpdatedValue;
    attributeUpdatedValue.SetS(attributeValue);
    Aws::Map<Aws::String, Aws::DynamoDB::Model::AttributeValue> expressionAttributeValues;
    expressionAttributeValues[":valueA"] = attributeUpdatedValue;
    request.SetExpressionAttributeValues(expressionAttributeValues);

    // Update the item.
    const Aws::DynamoDB::Model::UpdateItemOutcome &outcome = dynamoClient.UpdateItem(
            request);
    if (outcome.IsSuccess()) {
        std::cout << "Item was updated" << std::endl;
    } else {
        std::cerr << outcome.GetError().GetMessage() << std::endl;
        return false;
    }

    return waitTableActive(tableName, dynamoClient);
}
```

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

## Plus d'informations
<a name="more-info"></a>
+  [Directives relatives à l'utilisation des éléments](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/GuidelinesForItems.html) du guide du développeur Amazon DynamoDB
+  [Utilisation d'éléments dans DynamoDB dans](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/WorkingWithItems.html) le manuel du développeur Amazon DynamoDB

# Exemples d'Amazon EC2 utilisant le AWS SDK pour C\$1\$1
<a name="examples-ec2"></a>

Amazon Elastic Compute Cloud (Amazon EC2) est un service Web qui fournit une capacité de calcul redimensionnable (littéralement des serveurs dans les centres de données d'Amazon) que vous utilisez pour créer et héberger vos systèmes logiciels. Vous pouvez utiliser les exemples suivants pour programmer [Amazon EC2](https://aws.amazon.com/ec2) à l'aide du. AWS SDK pour C\$1\$1

**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.

**Topics**
+ [Gestion des instances Amazon EC2](examples-ec2-instances.md)
+ [Utilisation d'adresses IP élastiques dans Amazon EC2](examples-ec2-elastic-ip.md)
+ [Utilisation de régions et de zones de disponibilité pour Amazon EC2](examples-ec2-regions-zones.md)
+ [Utilisation des paires de clés Amazon EC2](examples-ec2-key-pairs.md)
+ [Utilisation des groupes de sécurité dans Amazon EC2](examples-ec2-security-groups.md)

# Gestion des instances Amazon EC2
<a name="examples-ec2-instances"></a>

## 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).

## Créer une instance
<a name="create-an-instance"></a>

Créez une nouvelle instance Amazon EC2 en appelant la `RunInstances` fonction du EC2 client, en lui fournissant un [RunInstancesRequest](https://docs.aws.amazon.com/sdk-for-cpp/latest/api/aws-cpp-sdk-ec2/html/class_aws_1_1_e_c2_1_1_model_1_1_run_instances_request.html)contenant l'[Amazon Machine Image (AMI)](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/AMIs.html) à utiliser et un type d'[instance](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/instance-types.html).

 **Comprend** 

```
#include <aws/core/Aws.h>
#include <aws/ec2/EC2Client.h>
#include <aws/ec2/model/RunInstancesRequest.h>
#include <iostream>
```

 **Code** 

```
    Aws::EC2::EC2Client ec2Client(clientConfiguration);

    Aws::EC2::Model::RunInstancesRequest runRequest;
    runRequest.SetImageId(amiId);
    runRequest.SetInstanceType(Aws::EC2::Model::InstanceType::t1_micro);
    runRequest.SetMinCount(1);
    runRequest.SetMaxCount(1);

    Aws::EC2::Model::RunInstancesOutcome runOutcome = ec2Client.RunInstances(
            runRequest);
    if (!runOutcome.IsSuccess()) {
        std::cerr << "Failed to launch EC2 instance " << instanceName <<
                  " based on ami " << amiId << ":" <<
                  runOutcome.GetError().GetMessage() << std::endl;
        return false;
    }

    const Aws::Vector<Aws::EC2::Model::Instance> &instances = runOutcome.GetResult().GetInstances();
    if (instances.empty()) {
        std::cerr << "Failed to launch EC2 instance " << instanceName <<
                  " based on ami " << amiId << ":" <<
                  runOutcome.GetError().GetMessage() << std::endl;
        return false;
    }
```

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

## Démarrer une instance
<a name="start-an-instance"></a>

Pour démarrer une instance Amazon EC2, appelez la `StartInstances` fonction du EC2 client en lui fournissant un [StartInstancesRequest](https://docs.aws.amazon.com/sdk-for-cpp/latest/api/aws-cpp-sdk-ec2/html/class_aws_1_1_e_c2_1_1_model_1_1_start_instances_request.html)contenant l'ID de l'instance à démarrer.

 **Comprend** 

```
#include <aws/ec2/EC2Client.h>
#include <aws/ec2/model/StartInstancesRequest.h>
```

 **Code** 

```
    Aws::EC2::EC2Client ec2Client(clientConfiguration);

    Aws::EC2::Model::StartInstancesRequest startRequest;
    startRequest.AddInstanceIds(instanceId);
    startRequest.SetDryRun(true);

    Aws::EC2::Model::StartInstancesOutcome dryRunOutcome = ec2Client.StartInstances(startRequest);
    if (dryRunOutcome.IsSuccess()) {
        std::cerr
                << "Failed dry run to start instance. A dry run should trigger an error."
                << std::endl;
        return false;
    } else if (dryRunOutcome.GetError().GetErrorType() !=
               Aws::EC2::EC2Errors::DRY_RUN_OPERATION) {
        std::cout << "Failed dry run to start instance " << instanceId << ": "
                  << dryRunOutcome.GetError().GetMessage() << std::endl;
        return false;
    }

    startRequest.SetDryRun(false);
    Aws::EC2::Model::StartInstancesOutcome startInstancesOutcome = ec2Client.StartInstances(startRequest);

    if (!startInstancesOutcome.IsSuccess()) {
        std::cout << "Failed to start instance " << instanceId << ": " <<
                  startInstancesOutcome.GetError().GetMessage() << std::endl;
    } else {
        std::cout << "Successfully started instance " << instanceId <<
                  std::endl;
    }
```

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

## Arrêter une instance
<a name="stop-an-instance"></a>

Pour arrêter une instance Amazon EC2, appelez la `StopInstances` fonction du EC2 client en lui fournissant un identifiant [StopInstancesRequest](https://docs.aws.amazon.com/sdk-for-cpp/latest/api/aws-cpp-sdk-ec2/html/class_aws_1_1_e_c2_1_1_model_1_1_stop_instances_request.html)contenant l'ID de l'instance à arrêter.

 **Comprend** 

```
#include <aws/ec2/model/StopInstancesRequest.h>
```

 **Code** 

```
    Aws::EC2::EC2Client ec2Client(clientConfiguration);
    Aws::EC2::Model::StopInstancesRequest request;
    request.AddInstanceIds(instanceId);
    request.SetDryRun(true);

    Aws::EC2::Model::StopInstancesOutcome dryRunOutcome = ec2Client.StopInstances(request);
    if (dryRunOutcome.IsSuccess()) {
        std::cerr
                << "Failed dry run to stop instance. A dry run should trigger an error."
                << std::endl;
        return false;
    } else if (dryRunOutcome.GetError().GetErrorType() !=
               Aws::EC2::EC2Errors::DRY_RUN_OPERATION) {
        std::cout << "Failed dry run to stop instance " << instanceId << ": "
                  << dryRunOutcome.GetError().GetMessage() << std::endl;
        return false;
    }

    request.SetDryRun(false);
    Aws::EC2::Model::StopInstancesOutcome outcome = ec2Client.StopInstances(request);
    if (!outcome.IsSuccess()) {
        std::cout << "Failed to stop instance " << instanceId << ": " <<
                  outcome.GetError().GetMessage() << std::endl;
    } else {
        std::cout << "Successfully stopped instance " << instanceId <<
                  std::endl;
    }
```

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

## Redémarrer une instance
<a name="reboot-an-instance"></a>

Pour redémarrer une instance Amazon EC2, appelez la `RebootInstances` fonction du EC2 client en lui fournissant un identifiant [RebootInstancesRequest](https://docs.aws.amazon.com/sdk-for-cpp/latest/api/aws-cpp-sdk-ec2/html/class_aws_1_1_e_c2_1_1_model_1_1_reboot_instances_request.html)contenant l'ID de l'instance à redémarrer.

 **Comprend** 

```
#include <aws/ec2/EC2Client.h>
#include <aws/ec2/model/RebootInstancesRequest.h>
#include <iostream>
```

 **Code** 

```
    Aws::EC2::EC2Client ec2Client(clientConfiguration);

    Aws::EC2::Model::RebootInstancesRequest request;
    request.AddInstanceIds(instanceId);
    request.SetDryRun(true);

    Aws::EC2::Model::RebootInstancesOutcome dry_run_outcome = ec2Client.RebootInstances(request);
    if (dry_run_outcome.IsSuccess()) {
        std::cerr
                << "Failed dry run to reboot on instance. A dry run should trigger an error."
                <<
                std::endl;
        return false;
    } else if (dry_run_outcome.GetError().GetErrorType()
               != Aws::EC2::EC2Errors::DRY_RUN_OPERATION) {
        std::cout << "Failed dry run to reboot instance " << instanceId << ": "
                  << dry_run_outcome.GetError().GetMessage() << std::endl;
        return false;
    }

    request.SetDryRun(false);
    Aws::EC2::Model::RebootInstancesOutcome outcome = ec2Client.RebootInstances(request);
    if (!outcome.IsSuccess()) {
        std::cout << "Failed to reboot instance " << instanceId << ": " <<
                  outcome.GetError().GetMessage() << std::endl;
    } else {
        std::cout << "Successfully rebooted instance " << instanceId <<
                  std::endl;
    }
```

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

## Description d'instances
<a name="describe-instances"></a>

Pour répertorier vos instances, créez une [DescribeInstancesRequest](https://docs.aws.amazon.com/sdk-for-cpp/latest/api/aws-cpp-sdk-ec2/html/class_aws_1_1_e_c2_1_1_model_1_1_describe_instances_request.html)et appelez la `DescribeInstances` fonction du EC2 client. Il renverra un [DescribeInstancesResponse](https://docs.aws.amazon.com/sdk-for-cpp/latest/api/aws-cpp-sdk-ec2/html/class_aws_1_1_e_c2_1_1_model_1_1_describe_instances_response.html)objet que vous pourrez utiliser pour répertorier les instances Amazon EC2 de votre Compte AWS et. Région AWS

Les instances sont regroupées par *réservation*. Chaque réservation correspond à l'appel de `StartInstances` qui a lancé l'instance. Pour répertorier vos instances, vous devez d'abord appeler la `GetReservations` fonction `DescribeInstancesResponse` de la classe, puis appeler `getInstances` chaque objet Reservation renvoyé.

 **Comprend** 

```
#include <aws/ec2/EC2Client.h>
#include <aws/ec2/model/DescribeInstancesRequest.h>
#include <aws/ec2/model/DescribeInstancesResponse.h>
#include <iomanip>
#include <iostream>
```

 **Code** 

```
    Aws::EC2::EC2Client ec2Client(clientConfiguration);
    Aws::EC2::Model::DescribeInstancesRequest request;
    bool header = false;
    bool done = false;
    while (!done) {
        Aws::EC2::Model::DescribeInstancesOutcome outcome = ec2Client.DescribeInstances(request);
        if (outcome.IsSuccess()) {
            if (!header) {
                std::cout << std::left <<
                          std::setw(48) << "Name" <<
                          std::setw(20) << "ID" <<
                          std::setw(25) << "Ami" <<
                          std::setw(15) << "Type" <<
                          std::setw(15) << "State" <<
                          std::setw(15) << "Monitoring" << std::endl;
                header = true;
            }

            const std::vector<Aws::EC2::Model::Reservation> &reservations =
                    outcome.GetResult().GetReservations();

            for (const auto &reservation: reservations) {
                const std::vector<Aws::EC2::Model::Instance> &instances =
                        reservation.GetInstances();
                for (const auto &instance: instances) {
                    Aws::String instanceStateString =
                            Aws::EC2::Model::InstanceStateNameMapper::GetNameForInstanceStateName(
                                    instance.GetState().GetName());

                    Aws::String typeString =
                            Aws::EC2::Model::InstanceTypeMapper::GetNameForInstanceType(
                                    instance.GetInstanceType());

                    Aws::String monitorString =
                            Aws::EC2::Model::MonitoringStateMapper::GetNameForMonitoringState(
                                    instance.GetMonitoring().GetState());
                    Aws::String name = "Unknown";

                    const std::vector<Aws::EC2::Model::Tag> &tags = instance.GetTags();
                    auto nameIter = std::find_if(tags.cbegin(), tags.cend(),
                                                 [](const Aws::EC2::Model::Tag &tag) {
                                                     return tag.GetKey() == "Name";
                                                 });
                    if (nameIter != tags.cend()) {
                        name = nameIter->GetValue();
                    }
                    std::cout <<
                              std::setw(48) << name <<
                              std::setw(20) << instance.GetInstanceId() <<
                              std::setw(25) << instance.GetImageId() <<
                              std::setw(15) << typeString <<
                              std::setw(15) << instanceStateString <<
                              std::setw(15) << monitorString << std::endl;
                }
            }

            if (!outcome.GetResult().GetNextToken().empty()) {
                request.SetNextToken(outcome.GetResult().GetNextToken());
            } else {
                done = true;
            }
        } else {
            std::cerr << "Failed to describe EC2 instances:" <<
                      outcome.GetError().GetMessage() << std::endl;
            return false;
        }
    }
```

Les résultats sont paginés ; vous pouvez obtenir d'autres résultats en transmettant la valeur renvoyée par la fonction de l'objet de résultat à la `GetNextToken` fonction de votre objet de `SetNextToken` demande d'origine, puis en utilisant le même objet de demande lors de votre prochain appel à`DescribeInstances`.

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

## Activer la surveillance des instances
<a name="enable-instance-monitoring"></a>

Vous pouvez surveiller différents aspects de vos instances Amazon EC2, tels que l'utilisation du processeur et du réseau, la mémoire disponible et l'espace disque restant. Pour en savoir plus sur la surveillance des instances, consultez la section [Surveillance d'Amazon EC2](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/monitoring_ec2.html) dans le guide de l'utilisateur Amazon EC2.

Pour commencer à surveiller une instance, vous devez en créer une [MonitorInstancesRequest](https://docs.aws.amazon.com/sdk-for-cpp/latest/api/aws-cpp-sdk-ec2/html/class_aws_1_1_e_c2_1_1_model_1_1_monitor_instances_request.html)avec l'ID de l'instance à surveiller et le transmettre à la `MonitorInstances` fonction du EC2 client.

 **Comprend** 

```
#include <aws/ec2/EC2Client.h>
#include <aws/ec2/model/MonitorInstancesRequest.h>
#include <aws/ec2/model/UnmonitorInstancesRequest.h>
#include <iostream>
```

 **Code** 

```
    Aws::EC2::EC2Client ec2Client(clientConfiguration);
    Aws::EC2::Model::MonitorInstancesRequest request;
    request.AddInstanceIds(instanceId);
    request.SetDryRun(true);

    Aws::EC2::Model::MonitorInstancesOutcome dryRunOutcome = ec2Client.MonitorInstances(request);
    if (dryRunOutcome.IsSuccess()) {
        std::cerr
                << "Failed dry run to enable monitoring on instance. A dry run should trigger an error."
                <<
                std::endl;
        return false;
    } else if (dryRunOutcome.GetError().GetErrorType()
               != Aws::EC2::EC2Errors::DRY_RUN_OPERATION) {
        std::cerr << "Failed dry run to enable monitoring on instance " <<
                  instanceId << ": " << dryRunOutcome.GetError().GetMessage() <<
                  std::endl;
        return false;
    }

    request.SetDryRun(false);
    Aws::EC2::Model::MonitorInstancesOutcome monitorInstancesOutcome = ec2Client.MonitorInstances(request);
    if (!monitorInstancesOutcome.IsSuccess()) {
        std::cerr << "Failed to enable monitoring on instance " <<
                  instanceId << ": " <<
                  monitorInstancesOutcome.GetError().GetMessage() << std::endl;
    } else {
        std::cout << "Successfully enabled monitoring on instance " <<
                  instanceId << std::endl;
    }
```

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

## Désactiver la surveillance des instances
<a name="disable-instance-monitoring"></a>

Pour arrêter de surveiller une instance, créez-en une [UnmonitorInstancesRequest](https://docs.aws.amazon.com/sdk-for-cpp/latest/api/aws-cpp-sdk-ec2/html/class_aws_1_1_e_c2_1_1_model_1_1_unmonitor_instances_request.html)avec l'ID de l'instance pour arrêter la surveillance et transmettez-la à la `UnmonitorInstances` fonction du EC2 client.

 **Comprend** 

```
#include <aws/ec2/EC2Client.h>
#include <aws/ec2/model/MonitorInstancesRequest.h>
#include <aws/ec2/model/UnmonitorInstancesRequest.h>
#include <iostream>
```

 **Code** 

```
    Aws::EC2::EC2Client ec2Client(clientConfiguration);
    Aws::EC2::Model::UnmonitorInstancesRequest unrequest;
    unrequest.AddInstanceIds(instanceId);
    unrequest.SetDryRun(true);

    Aws::EC2::Model::UnmonitorInstancesOutcome dryRunOutcome = ec2Client.UnmonitorInstances(unrequest);
    if (dryRunOutcome.IsSuccess()) {
        std::cerr
                << "Failed dry run to disable monitoring on instance. A dry run should trigger an error."
                <<
                std::endl;
        return false;
    } else if (dryRunOutcome.GetError().GetErrorType() !=
               Aws::EC2::EC2Errors::DRY_RUN_OPERATION) {
        std::cout << "Failed dry run to disable monitoring on instance " <<
                  instanceId << ": " << dryRunOutcome.GetError().GetMessage() <<
                  std::endl;
        return false;
    }

    unrequest.SetDryRun(false);
    Aws::EC2::Model::UnmonitorInstancesOutcome unmonitorInstancesOutcome = ec2Client.UnmonitorInstances(unrequest);
    if (!unmonitorInstancesOutcome.IsSuccess()) {
        std::cout << "Failed to disable monitoring on instance " << instanceId
                  << ": " << unmonitorInstancesOutcome.GetError().GetMessage() <<
                  std::endl;
    } else {
        std::cout << "Successfully disable monitoring on instance " <<
                  instanceId << std::endl;
    }
```

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

## En savoir plus
<a name="more-information"></a>
+  [RunInstances](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_RunInstances.html)dans la référence d'API Amazon EC2
+  [DescribeInstances](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_DescribeInstances.html)dans la référence d'API Amazon EC2
+  [StartInstances](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_StartInstances.html)dans la référence d'API Amazon EC2
+  [StopInstances](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_StopInstances.html)dans la référence d'API Amazon EC2
+  [RebootInstances](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_RebootInstances.html)dans la référence d'API Amazon EC2
+  [DescribeInstances](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_DescribeInstances.html)dans la référence d'API Amazon EC2
+  [MonitorInstances](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_MonitorInstances.html)dans la référence d'API Amazon EC2
+  [UnmonitorInstances](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_UnmonitorInstances.html)dans la référence d'API Amazon EC2

# Utilisation d'adresses IP élastiques dans Amazon EC2
<a name="examples-ec2-elastic-ip"></a>

## 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).

## Allouer une adresse IP élastique
<a name="allocate-an-elastic-ip-address"></a>

Pour utiliser une adresse IP Elastic, commencez par en attribuer une à votre compte, puis associez-la à votre instance ou à une interface réseau.

Pour allouer une adresse IP élastique, appelez la `AllocateAddress` fonction du EC2 client avec un [AllocateAddressRequest](https://docs.aws.amazon.com/sdk-for-cpp/latest/api/aws-cpp-sdk-ec2/html/class_aws_1_1_e_c2_1_1_model_1_1_allocate_address_request.html)objet contenant le type de réseau (EC2 ou VPC classique). 

**Avertissement**  
Nous retirons EC2-Classic le 15 août 2022. Nous vous recommandons de migrer d'EC2-Classic vers un VPC. [Pour plus d'informations, consultez la section **Migrer d'EC2-Classic vers un VPC** dans le guide de l'utilisateur Amazon EC2 pour les [instances Linux ou le guide de l'utilisateur Amazon EC2 pour](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/vpc-migrate.html) les instances Windows.](https://docs.aws.amazon.com/AWSEC2/latest/WindowsGuide/vpc-migrate.html) Consultez également le billet de blog [EC2-Classic Networking is Retiring – Here's How to Prepare](https://aws.amazon.com/blogs/aws/ec2-classic-is-retiring-heres-how-to-prepare/) (Se préparer au retrait de la mise en réseau EC2-Classic).

La [AllocateAddressResponse](https://docs.aws.amazon.com/sdk-for-cpp/latest/api/aws-cpp-sdk-ec2/html/class_aws_1_1_e_c2_1_1_model_1_1_allocate_address_response.html)classe de l'objet de réponse contient un ID d'allocation que vous pouvez utiliser pour associer l'adresse à une instance, en transmettant l'ID d'allocation et l'ID d'instance dans a [AssociateAddressRequest](https://docs.aws.amazon.com/sdk-for-cpp/latest/api/aws-cpp-sdk-ec2/html/class_aws_1_1_e_c2_1_1_model_1_1_associate_address_request.html)à la `AssociateAddress` fonction du EC2 client.

 **Comprend** 

```
#include <aws/ec2/EC2Client.h>
#include <aws/ec2/model/AllocateAddressRequest.h>
#include <aws/ec2/model/AssociateAddressRequest.h>
#include <iostream>
```

 **Code** 

```
    Aws::EC2::EC2Client ec2Client(clientConfiguration);

    Aws::EC2::Model::AllocateAddressRequest request;
    request.SetDomain(Aws::EC2::Model::DomainType::vpc);

    const Aws::EC2::Model::AllocateAddressOutcome outcome =
            ec2Client.AllocateAddress(request);
    if (!outcome.IsSuccess()) {
        std::cerr << "Failed to allocate Elastic IP address:" <<
                  outcome.GetError().GetMessage() << std::endl;
        return false;
    }
    const Aws::EC2::Model::AllocateAddressResponse &response = outcome.GetResult();
    allocationID = response.GetAllocationId();
    publicIPAddress = response.GetPublicIp();


    Aws::EC2::Model::AssociateAddressRequest associate_request;
    associate_request.SetInstanceId(instanceId);
    associate_request.SetAllocationId(allocationID);

    const Aws::EC2::Model::AssociateAddressOutcome associate_outcome =
            ec2Client.AssociateAddress(associate_request);
    if (!associate_outcome.IsSuccess()) {
        std::cerr << "Failed to associate Elastic IP address " << allocationID
                  << " with instance " << instanceId << ":" <<
                  associate_outcome.GetError().GetMessage() << std::endl;
        return false;
    }

    std::cout << "Successfully associated Elastic IP address " << allocationID
              << " with instance " << instanceId << std::endl;
```

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

## Description des adresses IP Elastic
<a name="describe-elastic-ip-addresses"></a>

Pour répertorier les adresses IP élastiques attribuées à votre compte, appelez la `DescribeAddresses` fonction du EC2 client. Il renvoie un objet de résultat [DescribeAddressesResponse](https://docs.aws.amazon.com/sdk-for-cpp/latest/api/aws-cpp-sdk-ec2/html/class_aws_1_1_e_c2_1_1_model_1_1_describe_addresses_response.html)qui contient un que vous pouvez utiliser pour obtenir une liste d'objets [Address](https://docs.aws.amazon.com/sdk-for-cpp/latest/api/aws-cpp-sdk-ec2/html/class_aws_1_1_e_c2_1_1_model_1_1_address.html) représentant les adresses IP élastiques de votre compte.

 **Comprend** 

```
#include <aws/ec2/EC2Client.h>
#include <aws/ec2/model/DescribeAddressesRequest.h>
#include <aws/ec2/model/DescribeAddressesResponse.h>
#include <iomanip>
#include <iostream>
```

 **Code** 

```
    Aws::EC2::EC2Client ec2Client(clientConfiguration);
    Aws::EC2::Model::DescribeAddressesRequest request;
    Aws::EC2::Model::DescribeAddressesOutcome outcome = ec2Client.DescribeAddresses(request);
    if (outcome.IsSuccess()) {
        std::cout << std::left << std::setw(20) << "InstanceId" <<
                  std::setw(15) << "Public IP" << std::setw(10) << "Domain" <<
                  std::setw(30) << "Allocation ID" << std::setw(25) <<
                  "NIC ID" << std::endl;

        const Aws::Vector<Aws::EC2::Model::Address> &addresses = outcome.GetResult().GetAddresses();
        for (const auto &address: addresses) {
            Aws::String domainString =
                    Aws::EC2::Model::DomainTypeMapper::GetNameForDomainType(
                            address.GetDomain());

            std::cout << std::left << std::setw(20) <<
                      address.GetInstanceId() << std::setw(15) <<
                      address.GetPublicIp() << std::setw(10) << domainString <<
                      std::setw(30) << address.GetAllocationId() << std::setw(25)
                      << address.GetNetworkInterfaceId() << std::endl;
        }
    } else {
        std::cerr << "Failed to describe Elastic IP addresses:" <<
                  outcome.GetError().GetMessage() << std::endl;
    }
```

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

## Libération d'une adresse IP Elastic
<a name="release-an-elastic-ip-address"></a>

Pour libérer une adresse IP élastique, appelez la `ReleaseAddress` fonction du EC2 client en lui transmettant un code [ReleaseAddressRequest](https://docs.aws.amazon.com/sdk-for-cpp/latest/api/aws-cpp-sdk-ec2/html/class_aws_1_1_e_c2_1_1_model_1_1_release_address_request.html)contenant l'ID d'allocation de l'adresse IP élastique que vous souhaitez libérer.

 **Comprend** 

```
#include <aws/ec2/EC2Client.h>
#include <aws/ec2/model/ReleaseAddressRequest.h>
#include <iostream>
```

 **Code** 

```
    Aws::EC2::EC2Client ec2(clientConfiguration);

    Aws::EC2::Model::ReleaseAddressRequest request;
    request.SetAllocationId(allocationID);

    Aws::EC2::Model::ReleaseAddressOutcome outcome = ec2.ReleaseAddress(request);
    if (!outcome.IsSuccess()) {
        std::cerr << "Failed to release Elastic IP address " <<
                  allocationID << ":" << outcome.GetError().GetMessage() <<
                  std::endl;
    } else {
        std::cout << "Successfully released Elastic IP address " <<
                  allocationID << std::endl;
    }
```

Une fois que vous avez publié une adresse IP élastique, elle est publiée dans le pool d'adresses AWS IP et il se peut que vous ne soyez plus disponible par la suite. Veillez à mettre à jour vos enregistrements DNS, ainsi que les serveurs ou les appareils qui communiquent avec l'adresse. Si vous tentez de libérer une adresse IP élastique que vous avez déjà publiée, un *AuthFailure*message d'erreur s'affichera si l'adresse est déjà attribuée à un autre AWS compte.

Si vous utilisez un *VPC par défaut*, la libération d'une adresse IP élastique la dissocie automatiquement de toute instance à laquelle elle est associée. Pour dissocier une adresse IP élastique sans la divulguer, utilisez la `DisassociateAddress` fonction du EC2 client.

Si vous utilisez un VPC autre que par défaut, vous *devez* utiliser `DisassociateAddress` pour dissocier l'adresse IP Elastic avant d'essayer de la libérer. *Dans le cas contraire, Amazon EC2 renvoie un message d'erreur (non valide). IPAddress InUse*).

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

## En savoir plus
<a name="more-information"></a>
+  [Adresses IP élastiques](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/elastic-ip-addresses-eip.html) dans le guide de l'utilisateur Amazon EC2
+  [AllocateAddress](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_AllocateAddress.html)dans le manuel de référence des API Amazon EC2
+  [DescribeAddresses](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_DescribeAddresses.html)dans le manuel de référence des API Amazon EC2
+  [ReleaseAddress](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_ReleaseAddress.html)dans le manuel de référence des API Amazon EC2

# Utilisation de régions et de zones de disponibilité pour Amazon EC2
<a name="examples-ec2-regions-zones"></a>

## 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écrire des régions
<a name="describe-regions"></a>

Pour répertorier ce qui Régions AWS est disponible pour vous Compte AWS, appelez la `DescribeRegions` fonction du EC2 client avec un [DescribeRegionsRequest](https://docs.aws.amazon.com/sdk-for-cpp/latest/api/aws-cpp-sdk-ec2/html/class_aws_1_1_e_c2_1_1_model_1_1_describe_regions_request.html).

Vous recevrez un objet [DescribeRegionsResponse](https://docs.aws.amazon.com/sdk-for-cpp/latest/api/aws-cpp-sdk-ec2/html/class_aws_1_1_e_c2_1_1_model_1_1_describe_regions_response.html)dans le résultat. Appelez sa `GetRegions` fonction pour obtenir une liste des objets [Region](https://docs.aws.amazon.com/sdk-for-cpp/latest/api/aws-cpp-sdk-ec2/html/class_aws_1_1_e_c2_1_1_model_1_1_region.html) qui représentent chaque Region.

 **Comprend** 

```
#include <aws/ec2/EC2Client.h>
#include <aws/ec2/model/DescribeRegionsRequest.h>
```

 **Code** 

```
    Aws::EC2::EC2Client ec2Client(clientConfiguration);

    Aws::EC2::Model::DescribeRegionsRequest request;
    Aws::EC2::Model::DescribeRegionsOutcome outcome = ec2Client.DescribeRegions(request);
    if (outcome.IsSuccess()) {
        std::cout << std::left <<
                  std::setw(32) << "RegionName" <<
                  std::setw(64) << "Endpoint" << std::endl;

        const auto &regions = outcome.GetResult().GetRegions();
        for (const auto &region: regions) {
            std::cout << std::left <<
                      std::setw(32) << region.GetRegionName() <<
                      std::setw(64) << region.GetEndpoint() << std::endl;
        }
    } else {
        std::cerr << "Failed to describe regions:" <<
                  outcome.GetError().GetMessage() << std::endl;
    }
```

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

## Décrire les zones de disponibilité
<a name="describe-availability-zones"></a>

Pour répertorier chaque zone de disponibilité disponible pour votre compte, appelez le service EC2 `DescribeAvailabilityZones` client avec un [DescribeAvailabilityZonesRequest](https://docs.aws.amazon.com/sdk-for-cpp/latest/api/aws-cpp-sdk-ec2/html/class_aws_1_1_e_c2_1_1_model_1_1_describe_availability_zones_request.html).

Vous recevrez un objet [DescribeAvailabilityZonesResponse](https://docs.aws.amazon.com/sdk-for-cpp/latest/api/aws-cpp-sdk-ec2/html/class_aws_1_1_e_c2_1_1_model_1_1_describe_availability_zones_response.html)dans le résultat. Appelez sa `GetAvailabilityZones` fonction pour obtenir une liste d'[AvailabilityZone](https://docs.aws.amazon.com/sdk-for-cpp/latest/api/aws-cpp-sdk-ec2/html/class_aws_1_1_e_c2_1_1_model_1_1_availability_zone.html)objets représentant chaque zone de disponibilité.

 **Comprend** 

```
#include <aws/ec2/model/DescribeAvailabilityZonesRequest.h>
```

 **Code** 

```
    Aws::EC2::Model::DescribeAvailabilityZonesRequest request;
    Aws::EC2::Model::DescribeAvailabilityZonesOutcome outcome = ec2Client.DescribeAvailabilityZones(request);

    if (outcome.IsSuccess()) {
        std::cout << std::left <<
                  std::setw(32) << "ZoneName" <<
                  std::setw(20) << "State" <<
                  std::setw(32) << "Region" << std::endl;

        const auto &zones =
                outcome.GetResult().GetAvailabilityZones();

        for (const auto &zone: zones) {
            Aws::String stateString =
                    Aws::EC2::Model::AvailabilityZoneStateMapper::GetNameForAvailabilityZoneState(
                            zone.GetState());
            std::cout << std::left <<
                      std::setw(32) << zone.GetZoneName() <<
                      std::setw(20) << stateString <<
                      std::setw(32) << zone.GetRegionName() << std::endl;
        }
    } else {
        std::cerr << "Failed to describe availability zones:" <<
                  outcome.GetError().GetMessage() << std::endl;

    }
```

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

## En savoir plus
<a name="more-information"></a>
+  [Régions et zones de disponibilité](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/using-regions-availability-zones.html) dans le guide de l'utilisateur Amazon EC2
+  [DescribeRegions](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_DescribeRegions.html)dans le manuel de référence des API Amazon EC2
+  [DescribeAvailabilityZones](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_DescribeAvailabilityZones.html)dans le manuel de référence des API Amazon EC2

# Utilisation des paires de clés Amazon EC2
<a name="examples-ec2-key-pairs"></a>

## 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).

## Créer une paire de clés
<a name="create-a-key-pair"></a>

Pour créer une paire de clés, appelez la `CreateKeyPair` fonction du EC2 client avec un [CreateKeyPairRequest](https://docs.aws.amazon.com/sdk-for-cpp/latest/api/aws-cpp-sdk-ec2/html/class_aws_1_1_e_c2_1_1_model_1_1_create_key_pair_request.html)contenant le nom de la clé.

 **Comprend** 

```
#include <aws/ec2/EC2Client.h>
#include <aws/ec2/model/CreateKeyPairRequest.h>
#include <iostream>
#include <fstream>
```

 **Code** 

```
    Aws::EC2::EC2Client ec2Client(clientConfiguration);
    Aws::EC2::Model::CreateKeyPairRequest request;
    request.SetKeyName(keyPairName);

    Aws::EC2::Model::CreateKeyPairOutcome outcome = ec2Client.CreateKeyPair(request);
    if (!outcome.IsSuccess()) {
        std::cerr << "Failed to create key pair - "  << keyPairName << ". " <<
                  outcome.GetError().GetMessage() << std::endl;
    } else {
        std::cout << "Successfully created key pair named " <<
                  keyPairName << std::endl;
        if (!keyFilePath.empty()) {
            std::ofstream keyFile(keyFilePath.c_str());
            keyFile << outcome.GetResult().GetKeyMaterial();
            keyFile.close();
            std::cout << "Keys written to the file " <<
                      keyFilePath << std::endl;
        }

    }
```

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

## Description de paires de clés
<a name="describe-key-pairs"></a>

Pour répertorier vos paires de clés ou pour obtenir des informations à leur sujet, appelez la `DescribeKeyPairs` fonction du EC2 client avec un [DescribeKeyPairsRequest](https://docs.aws.amazon.com/sdk-for-cpp/latest/api/aws-cpp-sdk-ec2/html/class_aws_1_1_e_c2_1_1_model_1_1_describe_key_pairs_request.html).

Vous recevrez un [DescribeKeyPairsResponse](https://docs.aws.amazon.com/sdk-for-cpp/latest/api/aws-cpp-sdk-ec2/html/class_aws_1_1_e_c2_1_1_model_1_1_describe_key_pairs_response.html)que vous pourrez utiliser pour accéder à la liste des paires de clés en appelant sa `GetKeyPairs` fonction, qui renvoie une liste d'[KeyPairInfo](https://docs.aws.amazon.com/sdk-for-cpp/latest/api/aws-cpp-sdk-ec2/html/class_aws_1_1_e_c2_1_1_model_1_1_key_pair_info.html)objets.

 **Comprend** 

```
#include <aws/ec2/EC2Client.h>
#include <aws/ec2/model/DescribeKeyPairsRequest.h>
#include <aws/ec2/model/DescribeKeyPairsResponse.h>
#include <iomanip>
#include <iostream>
```

 **Code** 

```
    Aws::EC2::EC2Client ec2Client(clientConfiguration);
    Aws::EC2::Model::DescribeKeyPairsRequest request;

    Aws::EC2::Model::DescribeKeyPairsOutcome outcome = ec2Client.DescribeKeyPairs(request);
    if (outcome.IsSuccess()) {
        std::cout << std::left <<
                  std::setw(32) << "Name" <<
                  std::setw(64) << "Fingerprint" << std::endl;

        const std::vector<Aws::EC2::Model::KeyPairInfo> &key_pairs =
                outcome.GetResult().GetKeyPairs();
        for (const auto &key_pair: key_pairs) {
            std::cout << std::left <<
                      std::setw(32) << key_pair.GetKeyName() <<
                      std::setw(64) << key_pair.GetKeyFingerprint() << std::endl;
        }
    } else {
        std::cerr << "Failed to describe key pairs:" <<
                  outcome.GetError().GetMessage() << std::endl;
    }
```

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

## Suppression d'une paire de clés
<a name="delete-a-key-pair"></a>

Pour supprimer une paire de clés, appelez la `DeleteKeyPair` fonction du EC2 client en lui transmettant un [DeleteKeyPairRequest](https://docs.aws.amazon.com/sdk-for-cpp/latest/api/aws-cpp-sdk-ec2/html/class_aws_1_1_e_c2_1_1_model_1_1_delete_key_pair_request.html)code contenant le nom de la paire de clés à supprimer.

 **Comprend** 

```
#include <aws/ec2/EC2Client.h>
#include <aws/ec2/model/DeleteKeyPairRequest.h>
#include <iostream>
```

 **Code** 

```
    Aws::EC2::EC2Client ec2Client(clientConfiguration);
    Aws::EC2::Model::DeleteKeyPairRequest request;

    request.SetKeyName(keyPairName);
    const Aws::EC2::Model::DeleteKeyPairOutcome outcome = ec2Client.DeleteKeyPair(
            request);

    if (!outcome.IsSuccess()) {
        std::cerr << "Failed to delete key pair " << keyPairName <<
                  ":" << outcome.GetError().GetMessage() << std::endl;
    } else {
        std::cout << "Successfully deleted key pair named " << keyPairName <<
                  std::endl;
    }
```

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

## En savoir plus
<a name="more-information"></a>
+  [Paires de clés Amazon EC2 dans le guide](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-key-pairs.html) de l'utilisateur Amazon EC2
+  [CreateKeyPair](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_CreateKeyPair.html)dans le manuel de référence des API Amazon EC2
+  [DescribeKeyPairs](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_DescribeKeyPairs.html)dans le manuel de référence des API Amazon EC2
+  [DeleteKeyPair](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_DeleteKeyPair.html)dans le manuel de référence des API Amazon EC2

# Utilisation des groupes de sécurité dans Amazon EC2
<a name="examples-ec2-security-groups"></a>

## 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).

## Créer un groupe de sécurité
<a name="create-a-security-group"></a>

Pour créer un groupe de sécurité, appelez la `CreateSecurityGroup` fonction du EC2 client avec un [CreateSecurityGroupRequest](https://docs.aws.amazon.com/sdk-for-cpp/latest/api/aws-cpp-sdk-ec2/html/class_aws_1_1_e_c2_1_1_model_1_1_create_security_group_request.html)qui contient le nom de la clé.

 **Comprend** 

```
#include <aws/ec2/EC2Client.h>
#include <aws/ec2/model/CreateSecurityGroupRequest.h>
```

 **Code** 

```
    Aws::EC2::EC2Client ec2Client(clientConfiguration);

    Aws::EC2::Model::CreateSecurityGroupRequest request;

    request.SetGroupName(groupName);
    request.SetDescription(description);
    request.SetVpcId(vpcID);

    const Aws::EC2::Model::CreateSecurityGroupOutcome outcome =
            ec2Client.CreateSecurityGroup(request);

    if (!outcome.IsSuccess()) {
        std::cerr << "Failed to create security group:" <<
                  outcome.GetError().GetMessage() << std::endl;
        return false;
    }

    std::cout << "Successfully created security group named " << groupName <<
              std::endl;
```

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

## Configurer un groupe de sécurité
<a name="configure-a-security-group"></a>

Un groupe de sécurité peut contrôler le trafic entrant (entrée) et sortant (sortie) vers vos instances Amazon EC2.

Pour ajouter des règles d'entrée à votre groupe de sécurité, utilisez la `AuthorizeSecurityGroupIngress` fonction du EC2 client, en fournissant le nom du groupe de sécurité et les règles d'accès ([IpPermission](https://docs.aws.amazon.com/sdk-for-cpp/latest/api/aws-cpp-sdk-ec2/html/class_aws_1_1_e_c2_1_1_model_1_1_ip_permission.html)) que vous souhaitez lui attribuer dans un [AuthorizeSecurityGroupIngressRequest](https://docs.aws.amazon.com/sdk-for-cpp/latest/api/aws-cpp-sdk-ec2/html/class_aws_1_1_e_c2_1_1_model_1_1_authorize_security_group_ingress_request.html)objet. L'exemple suivant montre comment ajouter des autorisations IP à un groupe de sécurité.

 **Comprend** 

```
#include <aws/ec2/model/AuthorizeSecurityGroupIngressRequest.h>
```

 **Code** 

```
    Aws::EC2::Model::AuthorizeSecurityGroupIngressRequest authorizeSecurityGroupIngressRequest;
    authorizeSecurityGroupIngressRequest.SetGroupId(groupID);
```

```
    Aws::String ingressIPRange = "203.0.113.0/24";  // Configure this for your allowed IP range.
    Aws::EC2::Model::IpRange ip_range;
    ip_range.SetCidrIp(ingressIPRange);

    Aws::EC2::Model::IpPermission permission1;
    permission1.SetIpProtocol("tcp");
    permission1.SetToPort(80);
    permission1.SetFromPort(80);
    permission1.AddIpRanges(ip_range);

    authorize_request.AddIpPermissions(permission1);

    Aws::EC2::Model::IpPermission permission2;
    permission2.SetIpProtocol("tcp");
    permission2.SetToPort(22);
    permission2.SetFromPort(22);
    permission2.AddIpRanges(ip_range);

    authorize_request.AddIpPermissions(permission2);
```

```
    Aws::EC2::Model::AuthorizeSecurityGroupIngressOutcome authorizeSecurityGroupIngressOutcome =
            ec2Client.AuthorizeSecurityGroupIngress(authorizeSecurityGroupIngressRequest);

    if (authorizeSecurityGroupIngressOutcome.IsSuccess()) {
        std::cout << "Successfully authorized security group ingress." << std::endl;
    } else {
        std::cerr << "Error authorizing security group ingress: "
                  << authorizeSecurityGroupIngressOutcome.GetError().GetMessage() << std::endl;
    }
```

Pour ajouter une règle de sortie au groupe de sécurité, fournissez des données similaires dans une [AuthorizeSecurityGroupEgressRequest](https://docs.aws.amazon.com/sdk-for-cpp/latest/api/aws-cpp-sdk-ec2/html/class_aws_1_1_e_c2_1_1_model_1_1_authorize_security_group_egress_request.html)`AuthorizeSecurityGroupEgress`fonction du EC2 client.

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

## Description des groupes de sécurité
<a name="describe-security-groups"></a>

Pour décrire vos groupes de sécurité ou obtenir des informations à leur sujet, appelez la `DescribeSecurityGroups` fonction du EC2 client avec un [DescribeSecurityGroupsRequest](https://docs.aws.amazon.com/sdk-for-cpp/latest/api/aws-cpp-sdk-ec2/html/class_aws_1_1_e_c2_1_1_model_1_1_describe_security_groups_request.html).

Vous recevrez un objet [DescribeSecurityGroupsResponse](https://docs.aws.amazon.com/sdk-for-cpp/latest/api/aws-cpp-sdk-ec2/html/class_aws_1_1_e_c2_1_1_model_1_1_describe_security_groups_response.html)dans le résultat que vous pourrez utiliser pour accéder à la liste des groupes de sécurité en appelant sa `GetSecurityGroups` fonction, qui renvoie une liste d'[SecurityGroup](https://docs.aws.amazon.com/sdk-for-cpp/latest/api/aws-cpp-sdk-ec2/html/class_aws_1_1_e_c2_1_1_model_1_1_security_group.html)objets.

 **Comprend** 

```
#include <aws/ec2/EC2Client.h>
#include <aws/ec2/model/DescribeSecurityGroupsRequest.h>
#include <aws/ec2/model/DescribeSecurityGroupsResponse.h>
#include <iomanip>
#include <iostream>
```

 **Code** 

```
    Aws::EC2::EC2Client ec2Client(clientConfiguration);
    Aws::EC2::Model::DescribeSecurityGroupsRequest request;

    if (!groupID.empty()) {
        request.AddGroupIds(groupID);
    }

    Aws::String nextToken;
    do {
        if (!nextToken.empty()) {
            request.SetNextToken(nextToken);
        }

        Aws::EC2::Model::DescribeSecurityGroupsOutcome outcome = ec2Client.DescribeSecurityGroups(request);
        if (outcome.IsSuccess()) {
            std::cout << std::left <<
                      std::setw(32) << "Name" <<
                      std::setw(30) << "GroupId" <<
                      std::setw(30) << "VpcId" <<
                      std::setw(64) << "Description" << std::endl;

            const std::vector<Aws::EC2::Model::SecurityGroup> &securityGroups =
                    outcome.GetResult().GetSecurityGroups();

            for (const auto &securityGroup: securityGroups) {
                std::cout << std::left <<
                          std::setw(32) << securityGroup.GetGroupName() <<
                          std::setw(30) << securityGroup.GetGroupId() <<
                          std::setw(30) << securityGroup.GetVpcId() <<
                          std::setw(64) << securityGroup.GetDescription() <<
                          std::endl;
            }
        } else {
            std::cerr << "Failed to describe security groups:" <<
                      outcome.GetError().GetMessage() << std::endl;
            return false;
        }

        nextToken = outcome.GetResult().GetNextToken();
    } while (!nextToken.empty());
```

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

## Supprimer un groupe de sécurité
<a name="delete-a-security-group"></a>

Pour supprimer un groupe de sécurité, appelez la `DeleteSecurityGroup` fonction du EC2 client en lui transmettant un identifiant [DeleteSecurityGroupRequest](https://docs.aws.amazon.com/sdk-for-cpp/latest/api/aws-cpp-sdk-ec2/html/class_aws_1_1_e_c2_1_1_model_1_1_delete_security_group_request.html)contenant l'ID du groupe de sécurité à supprimer.

 **Comprend** 

```
#include <aws/ec2/EC2Client.h>
#include <aws/ec2/model/DeleteSecurityGroupRequest.h>
#include <iostream>
```

 **Code** 

```
    Aws::EC2::EC2Client ec2Client(clientConfiguration);
    Aws::EC2::Model::DeleteSecurityGroupRequest request;

    request.SetGroupId(securityGroupID);
    Aws::EC2::Model::DeleteSecurityGroupOutcome outcome = ec2Client.DeleteSecurityGroup(request);

    if (!outcome.IsSuccess()) {
        std::cerr << "Failed to delete security group " << securityGroupID <<
                  ":" << outcome.GetError().GetMessage() << std::endl;
    } else {
        std::cout << "Successfully deleted security group " << securityGroupID <<
                  std::endl;
    }
```

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

## En savoir plus
<a name="more-information"></a>
+  [Groupes de sécurité Amazon EC2](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-key-pairs.html) dans le guide de l'utilisateur Amazon EC2
+  [Autorisation du trafic entrant pour vos instances Linux](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/authorizing-access-to-an-instance.html) dans le guide de l'utilisateur Amazon EC2
+  [CreateSecurityGroup](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_CreateSecurityGroup.html)dans le manuel de référence des API Amazon EC2
+  [DescribeSecurityGroups](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_DescribeSecurityGroups.html)dans le manuel de référence des API Amazon EC2
+  [DeleteSecurityGroup](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_DeleteSecurityGroup.html)dans le manuel de référence des API Amazon EC2
+  [AuthorizeSecurityGroupIngress](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_AuthorizeSecurityGroupIngress.html)dans le manuel de référence des API Amazon EC2

# 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).

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

Amazon Simple Queue Service (Amazon SQS) est un service de mise en file d'attente de messages entièrement géré qui facilite le découplage et le dimensionnement des microservices, des systèmes distribués et des applications sans serveur. Vous pouvez utiliser les exemples suivants pour programmer [Amazon SQS](https://aws.amazon.com/sqs) à l'aide du. AWS SDK pour C\$1\$1

**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.

**Topics**
+ [Utilisation des files d'attente de messages Amazon SQS](examples-sqs-message-queues.md)
+ [Envoyer, recevoir et supprimer des messages Amazon SQS](examples-sqs-messages.md)
+ [Activation des longues interrogations pour les files d'attente de messages Amazon SQS](examples-sqs-long-polling.md)
+ [Configuration du délai de visibilité dans Amazon SQS](examples-sqs-visibility-timeout.md)
+ [Utilisation des files d'attente de lettres mortes dans Amazon SQS](examples-sqs-dead-letter-queues.md)

# Utilisation des files d'attente de messages Amazon SQS
<a name="examples-sqs-message-queues"></a>

Une *file de messages* est le conteneur logique que vous utilisez pour envoyer des messages de manière fiable dans Amazon SQS. Il existe deux types de files d'attente : *standard* et *FIFO* (premier entré, premier sorti). Pour en savoir plus sur les files d'attente et les différences entre ces types, consultez le [guide du développeur Amazon Simple Queue Service](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/).

Ces exemples C\$1\$1 vous montrent comment utiliser le AWS SDK pour C\$1\$1 pour créer, répertorier, supprimer et obtenir l'URL d'une file d'attente Amazon SQS.

## 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).

## Création d'une file d'attente
<a name="sqs-create-queue"></a>

Utilisez la fonction SQSClient de `CreateQueue` membre de classe et fournissez-lui un [CreateQueueRequest](https://docs.aws.amazon.com/sdk-for-cpp/latest/api/aws-cpp-sdk-sqs/html/class_aws_1_1_s_q_s_1_1_model_1_1_create_queue_request.html)objet décrivant les paramètres de la file d'attente.

 **Comprend** 

```
#include <aws/core/Aws.h>
#include <aws/sqs/SQSClient.h>
#include <aws/sqs/model/CreateQueueRequest.h>
#include <iostream>
```

 **Code** 

```
    Aws::SQS::SQSClient sqsClient(clientConfiguration);

    Aws::SQS::Model::CreateQueueRequest request;
    request.SetQueueName(queueName);

    const Aws::SQS::Model::CreateQueueOutcome outcome = sqsClient.CreateQueue(request);
    if (outcome.IsSuccess()) {
        std::cout << "Successfully created queue " << queueName << " with a queue URL "
                  << outcome.GetResult().GetQueueUrl() << "." << std::endl;
    }
    else {
        std::cerr << "Error creating queue " << queueName << ": " <<
                  outcome.GetError().GetMessage() << std::endl;
    }
```

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

## Répertorier les files d'attente
<a name="sqs-list-queues"></a>

Pour répertorier les files d'attente Amazon SQS pour votre compte, appelez la fonction SQSClient class `ListQueues` member et transmettez-lui un objet. [ListQueuesRequest](https://docs.aws.amazon.com/sdk-for-cpp/latest/api/aws-cpp-sdk-sqs/html/class_aws_1_1_s_q_s_1_1_model_1_1_list_queues_request.html)

 **Comprend** 

```
#include <aws/core/Aws.h>
#include <aws/sqs/SQSClient.h>
#include <aws/sqs/model/ListQueuesRequest.h>
#include <iostream>
```

 **Code** 

```
    Aws::SQS::SQSClient sqsClient(clientConfiguration);

    Aws::SQS::Model::ListQueuesRequest listQueuesRequest;

    Aws::String nextToken; // Used for pagination.
    Aws::Vector<Aws::String> allQueueUrls;

    do {
        if (!nextToken.empty()) {
            listQueuesRequest.SetNextToken(nextToken);
        }
        const Aws::SQS::Model::ListQueuesOutcome outcome = sqsClient.ListQueues(
                listQueuesRequest);
        if (outcome.IsSuccess()) {
            const Aws::Vector<Aws::String> &queueUrls = outcome.GetResult().GetQueueUrls();
            allQueueUrls.insert(allQueueUrls.end(),
                                queueUrls.begin(),
                                queueUrls.end());

            nextToken = outcome.GetResult().GetNextToken();
        }
        else {
            std::cerr << "Error listing queues: " <<
                      outcome.GetError().GetMessage() << std::endl;
            return false;
        }

    } while (!nextToken.empty());

    std::cout << allQueueUrls.size() << " Amazon SQS queue(s) found." << std::endl;
    for (const auto &iter: allQueueUrls) {
        std::cout << " " << iter << std::endl;
    }
```

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

## Obtenir l'URL de la file d'attente
<a name="sqs-get-queue-url"></a>

Pour obtenir l'URL d'une file d'attente Amazon SQS existante, appelez la fonction SQSClient class `GetQueueUrl` member.

 **Comprend** 

```
#include <aws/core/Aws.h>
#include <aws/sqs/SQSClient.h>
#include <aws/sqs/model/GetQueueUrlRequest.h>
#include <iostream>
```

 **Code** 

```
    Aws::SQS::SQSClient sqsClient(clientConfiguration);

    Aws::SQS::Model::GetQueueUrlRequest request;
    request.SetQueueName(queueName);

    const Aws::SQS::Model::GetQueueUrlOutcome outcome = sqsClient.GetQueueUrl(request);
    if (outcome.IsSuccess()) {
        std::cout << "Queue " << queueName << " has url " <<
                  outcome.GetResult().GetQueueUrl() << std::endl;
    }
    else {
        std::cerr << "Error getting url for queue " << queueName << ": " <<
                  outcome.GetError().GetMessage() << std::endl;
    }
```

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

## Suppression d'une file d'attente
<a name="sqs-delete-queue"></a>

Fournissez l'[URL](#sqs-get-queue-url) de la fonction `DeleteQueue` membre de SQSClient classe.

 **Comprend** 

```
#include <aws/core/Aws.h>
#include <aws/core/client/DefaultRetryStrategy.h>
#include <aws/sqs/SQSClient.h>
#include <aws/sqs/model/DeleteQueueRequest.h>
#include <iostream>
```

 **Code** 

```
    Aws::SQS::Model::DeleteQueueRequest request;
    request.SetQueueUrl(queueURL);

    const Aws::SQS::Model::DeleteQueueOutcome outcome = sqsClient.DeleteQueue(request);
    if (outcome.IsSuccess()) {
        std::cout << "Successfully deleted queue with url " << queueURL <<
                  std::endl;
    }
    else {
        std::cerr << "Error deleting queue " << queueURL << ": " <<
                  outcome.GetError().GetMessage() << std::endl;
    }
```

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

## Plus d'informations
<a name="more-info"></a>
+  [Comment fonctionnent les files d'attente Amazon SQS dans le guide](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/sqs-how-it-works.html) du développeur Amazon Simple Queue Service
+  [CreateQueue](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/API_CreateQueue.html)dans la référence de l'API Amazon Simple Queue Service
+  [GetQueueUrl](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/API_GetQueueUrl.html)dans la référence de l'API Amazon Simple Queue Service
+  [ListQueues](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/API_ListQueues.html)dans la référence de l'API Amazon Simple Queue Service
+  [DeleteQueues](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/API_DeleteQueues.html)dans la référence de l'API Amazon Simple Queue Service

# Envoyer, recevoir et supprimer des messages Amazon SQS
<a name="examples-sqs-messages"></a>

Les messages sont toujours délivrés à l'aide d'une file d'[attente SQS.](examples-sqs-message-queues.md) Ces exemples C\$1\$1 vous montrent comment utiliser le AWS SDK pour C\$1\$1 pour envoyer, recevoir et supprimer des messages Amazon SQS des files d'attente SQS.

## 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).

## Envoi d'un message
<a name="sqs-message-send"></a>

Vous pouvez ajouter un message unique à une file d'attente Amazon SQS en appelant la fonction SQSClient class `SendMessage` member. Vous fournissez `SendMessage` un [SendMessageRequest](https://docs.aws.amazon.com/sdk-for-cpp/latest/api/aws-cpp-sdk-sqs/html/class_aws_1_1_s_q_s_1_1_model_1_1_send_message_request.html)objet contenant l'[URL](examples-sqs-message-queues.md#sqs-get-queue-url) de la file d'attente, le corps du message et une valeur de délai facultative (en secondes).

 **Comprend** 

```
#include <aws/core/Aws.h>
#include <aws/sqs/SQSClient.h>
#include <aws/sqs/model/SendMessageRequest.h>
#include <iostream>
```

 **Code** 

```
    Aws::SQS::SQSClient sqsClient(clientConfiguration);

    Aws::SQS::Model::SendMessageRequest request;
    request.SetQueueUrl(queueUrl);
    request.SetMessageBody(messageBody);

    const Aws::SQS::Model::SendMessageOutcome outcome = sqsClient.SendMessage(request);
    if (outcome.IsSuccess()) {
        std::cout << "Successfully sent message to " << queueUrl <<
                  std::endl;
    }
    else {
        std::cerr << "Error sending message to " << queueUrl << ": " <<
                  outcome.GetError().GetMessage() << std::endl;
    }
```

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

## Réception de messages
<a name="sqs-messages-receive"></a>

Récupérez tous les messages actuellement dans la file d'attente en appelant la fonction `ReceiveMessage` membre de SQSClient classe et en lui transmettant l'URL de la file d'attente. Les messages sont renvoyés sous la forme d'une liste d'objets [Message](https://docs.aws.amazon.com/sdk-for-cpp/latest/api/aws-cpp-sdk-sqs/html/class_aws_1_1_s_q_s_1_1_model_1_1_message.html).

 **Comprend** 

```
#include <aws/core/Aws.h>
#include <aws/sqs/SQSClient.h>
#include <aws/sqs/model/ReceiveMessageRequest.h>
#include <iostream>
```

 **Code** 

```
    Aws::SQS::SQSClient sqsClient(clientConfiguration);

    Aws::SQS::Model::ReceiveMessageRequest request;
    request.SetQueueUrl(queueUrl);
    request.SetMaxNumberOfMessages(1);

    const Aws::SQS::Model::ReceiveMessageOutcome outcome = sqsClient.ReceiveMessage(
            request);
    if (outcome.IsSuccess()) {

        const Aws::Vector<Aws::SQS::Model::Message> &messages =
                outcome.GetResult().GetMessages();
        if (!messages.empty()) {
            const Aws::SQS::Model::Message &message = messages[0];
            std::cout << "Received message:" << std::endl;
            std::cout << "  MessageId: " << message.GetMessageId() << std::endl;
            std::cout << "  ReceiptHandle: " << message.GetReceiptHandle() << std::endl;
            std::cout << "  Body: " << message.GetBody() << std::endl << std::endl;
        }
        else {
            std::cout << "No messages received from queue " << queueUrl <<
                      std::endl;

        }
    }
    else {
        std::cerr << "Error receiving message from queue " << queueUrl << ": "
                  << outcome.GetError().GetMessage() << std::endl;
    }
```

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

### Suppression des messages après réception
<a name="sqs-messages-delete"></a>

Après avoir reçu un message et traité son contenu, supprimez-le de la file d'attente en envoyant le descripteur de réception du message et l'URL de la file d'attente à la fonction `DeleteMessage` membre de la SQSClient classe.

 **Comprend** 

```
#include <aws/core/Aws.h>
#include <aws/sqs/SQSClient.h>
#include <aws/sqs/model/DeleteMessageRequest.h>
#include <iostream>
```

 **Code** 

```
    Aws::SQS::Model::DeleteMessageRequest request;
    request.SetQueueUrl(queueUrl);
    request.SetReceiptHandle(messageReceiptHandle);

    const Aws::SQS::Model::DeleteMessageOutcome outcome = sqsClient.DeleteMessage(
            request);
    if (outcome.IsSuccess()) {
        std::cout << "Successfully deleted message from queue " << queueUrl
                  << std::endl;
    }
    else {
        std::cerr << "Error deleting message from queue " << queueUrl << ": " <<
                  outcome.GetError().GetMessage() << std::endl;
    }
```

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

## Plus d'informations
<a name="more-info"></a>
+  [Comment fonctionnent les files d'attente Amazon SQS dans le guide](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/sqs-how-it-works.html) du développeur Amazon Simple Queue Service
+  [SendMessage](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/API_SendMessage.html)dans la référence de l'API Amazon Simple Queue Service
+  [SendMessageBatch](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/API_SendMessageBatch.html)dans la référence de l'API Amazon Simple Queue Service
+  [ReceiveMessage](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/API_ReceiveMessage.html)dans la référence de l'API Amazon Simple Queue Service
+  [DeleteMessage](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/API_DeleteMessage.html)dans la référence de l'API Amazon Simple Queue Service

# Activation des longues interrogations pour les files d'attente de messages Amazon SQS
<a name="examples-sqs-long-polling"></a>

Amazon SQS utilise des interrogations *courtes par* défaut, interrogeant uniquement un sous-ensemble des serveurs, sur la base d'une distribution aléatoire pondérée, afin de déterminer si des messages peuvent être inclus dans la réponse.

Les longs sondages permettent de réduire le coût d'utilisation d'Amazon SQS en réduisant le nombre de réponses vides lorsqu'aucun message n'est disponible pour répondre à une ReceiveMessage demande envoyée à une file d'attente Amazon SQS et en éliminant les fausses réponses vides. Vous pouvez définir une fréquence d'attente active de longue durée de *1 à 20 secondes*.

## 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).

## Activer les longs sondages lors de la création d'une file d'attente
<a name="sqs-long-polling-create-queue"></a>

Pour permettre un long sondage lors de la création d'une file d'attente Amazon SQS, définissez l'`ReceiveMessageWaitTimeSeconds`attribut sur l'[CreateQueueRequest](https://docs.aws.amazon.com/sdk-for-cpp/latest/api/aws-cpp-sdk-sqs/html/class_aws_1_1_s_q_s_1_1_model_1_1_create_queue_request.html)objet avant d'appeler la fonction membre de la SQSClient classe. `CreateQueue`

 **Comprend** 

```
#include <aws/core/Aws.h>
#include <aws/sqs/SQSClient.h>
#include <aws/sqs/model/CreateQueueRequest.h>
#include <iostream>
```

 **Code** 

```
    Aws::SQS::SQSClient sqsClient(clientConfiguration);

    Aws::SQS::Model::CreateQueueRequest request;
    request.SetQueueName(queueName);
    request.AddAttributes(
            Aws::SQS::Model::QueueAttributeName::ReceiveMessageWaitTimeSeconds,
            pollTimeSeconds);

    const Aws::SQS::Model::CreateQueueOutcome outcome = sqsClient.CreateQueue(request);
    if (outcome.IsSuccess()) {
        std::cout << "Successfully created queue " << queueName <<
                  std::endl;
    }
    else {
        std::cout << "Error creating queue " << queueName << ": " <<
                  outcome.GetError().GetMessage() << std::endl;
    }
```

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

## Activation de l'attente active de longue durée sur une file d'attente existante
<a name="sqs-long-polling-existing-queue"></a>

En plus de permettre un long sondage lors de la création d'une file d'attente, vous pouvez également l'activer sur une file d'attente existante en activant la `ReceiveMessageWaitTimeSeconds` fonction `SetQueueAttributes` membre de la SQSClient classe [SetQueueAttributesRequest](https://docs.aws.amazon.com/sdk-for-cpp/latest/api/aws-cpp-sdk-sqs/html/class_aws_1_1_s_q_s_1_1_model_1_1_set_queue_attributes_request.html)avant d'appeler.

 **Comprend** 

```
#include <aws/core/Aws.h>
#include <aws/sqs/SQSClient.h>
#include <aws/sqs/model/SetQueueAttributesRequest.h>
#include <iostream>
```

 **Code** 

```
    Aws::SQS::SQSClient sqsClient(clientConfiguration);

    Aws::SQS::Model::SetQueueAttributesRequest request;
    request.SetQueueUrl(queueURL);
    request.AddAttributes(
            Aws::SQS::Model::QueueAttributeName::ReceiveMessageWaitTimeSeconds,
            pollTimeSeconds);

    const Aws::SQS::Model::SetQueueAttributesOutcome outcome = sqsClient.SetQueueAttributes(
            request);
    if (outcome.IsSuccess()) {
        std::cout << "Successfully updated long polling time for queue " <<
                  queueURL << " to " << pollTimeSeconds << std::endl;
    }
    else {
        std::cout << "Error updating long polling time for queue " <<
                  queueURL << ": " << outcome.GetError().GetMessage() <<
                  std::endl;
    }
```

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

## Activation de l'attente active de longue durée à la réception de messages
<a name="sqs-long-polling-receive-message"></a>

Vous pouvez activer les longues interrogations lors de la réception d'un message en réglant le temps d'attente en secondes [ReceiveMessageRequest](https://docs.aws.amazon.com/sdk-for-cpp/latest/api/aws-cpp-sdk-sqs/html/class_aws_1_1_s_q_s_1_1_model_1_1_receive_message_request.html)que vous indiquez à la fonction ReceiveMessage membre SQSClient de la classe.

**Note**  
Vous devez vous assurer que le délai d'expiration des demandes du AWS client est supérieur à la durée maximale du sondage (20 secondes) afin que vos `ReceiveMessage` demandes ne soient pas expirées en attendant le prochain événement du sondage \$1

 **Comprend** 

```
#include <aws/core/Aws.h>
#include <aws/sqs/SQSClient.h>
#include <aws/sqs/model/ReceiveMessageRequest.h>
```

 **Code** 

```
    Aws::SQS::SQSClient sqsClient(customConfiguration);

    Aws::SQS::Model::ReceiveMessageRequest request;
    request.SetQueueUrl(queueUrl);
    request.SetMaxNumberOfMessages(1);
    request.SetWaitTimeSeconds(waitTimeSeconds);

    auto outcome = sqsClient.ReceiveMessage(request);
    if (outcome.IsSuccess()) {
        const auto &messages = outcome.GetResult().GetMessages();
        if (messages.empty()) {
            std::cout << "No messages received from queue " << queueUrl <<
                      std::endl;
        }
        else {
            const auto &message = messages[0];
            std::cout << "Received message:" << std::endl;
            std::cout << "  MessageId: " << message.GetMessageId() << std::endl;
            std::cout << "  ReceiptHandle: " << message.GetReceiptHandle() << std::endl;
            std::cout << "  Body: " << message.GetBody() << std::endl << std::endl;
        }
    }
    else {
        std::cout << "Error receiving message from queue " << queueUrl << ": "
                  << outcome.GetError().GetMessage() << std::endl;
    }
```

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

## Plus d'informations
<a name="more-info"></a>
+  [Amazon SQS Long Solling](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/sqs-long-polling.html) dans le guide du développeur Amazon Simple Queue Service
+  [CreateQueue](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/API_CreateQueue.html)dans la référence de l'API Amazon Simple Queue Service
+  [ReceiveMessage](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/API_ReceiveMessage.html)dans la référence de l'API Amazon Simple Queue Service
+  [SetQueueAttributes](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/API_SetQueueAttributes.html)dans la référence de l'API Amazon Simple Queue Service

# Configuration du délai de visibilité dans Amazon SQS
<a name="examples-sqs-visibility-timeout"></a>

Lorsqu'un message est reçu dans Amazon SQS, il reste dans la file d'attente jusqu'à ce qu'il soit supprimé afin de garantir sa réception. Un message qui a été reçu, mais pas supprimé, est disponible dans les demandes suivantes après un *délai de visibilité* donné afin d'empêcher que le message ne soit reçu plusieurs fois avant d'être traité et supprimé.

Lorsque vous utilisez les [files d'attente standard](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/standard-queues.html), le délai de visibilité n'est pas une garantie que vous ne recevrez pas deux fois un même message. Si vous utilisez une file d'attente standard, assurez-vous que votre code gère le cas où le même message est remis plusieurs fois.

## 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éfinissez le délai de visibilité des messages à la réception du message
<a name="sqs-visibility-timeout-receipt"></a>

Lorsque vous avez reçu un message, vous pouvez modifier son délai de visibilité en transmettant son identifiant de réception à la fonction `ChangeMessageVisibility` membre de la SQSClient classe. [ChangeMessageVisibilityRequest](https://docs.aws.amazon.com/sdk-for-cpp/latest/api/aws-cpp-sdk-sqs/html/class_aws_1_1_s_q_s_1_1_model_1_1_change_message_visibility_request.html)

 **Comprend** 

```
#include <aws/core/Aws.h>
#include <aws/sqs/SQSClient.h>
#include <aws/sqs/model/ChangeMessageVisibilityRequest.h>
#include <aws/sqs/model/ReceiveMessageRequest.h>
#include <iostream>
```

 **Code** 

```
    Aws::SQS::Model::ChangeMessageVisibilityRequest request;
    request.SetQueueUrl(queue_url);
    request.SetReceiptHandle(messageReceiptHandle);
    request.SetVisibilityTimeout(visibilityTimeoutSeconds);

    auto outcome = sqsClient.ChangeMessageVisibility(request);
    if (outcome.IsSuccess()) {
        std::cout << "Successfully changed visibility of message " <<
                  messageReceiptHandle << " from queue " << queue_url << std::endl;
    }
    else {
        std::cout << "Error changing visibility of message from queue "
                  << queue_url << ": " <<
                  outcome.GetError().GetMessage() << std::endl;
    }
```

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

## Plus d'informations
<a name="more-info"></a>
+  [Délai de visibilité indiqué](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/sqs-visibility-timeout.html) dans le guide du développeur du service Amazon Simple Queue
+  [SetQueueAttributes](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/API_SetQueueAttributes.html)dans la référence de l'API Amazon Simple Queue Service
+  [GetQueueAttributes](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/API_GetQueueAttributes.html)dans la référence de l'API Amazon Simple Queue Service
+  [ReceiveMessage](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/API_ReceiveMessage.html)dans la référence de l'API Amazon Simple Queue Service
+  [ChangeMessageVisibility](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/API_ChangeMessageVisibility.html)dans la référence de l'API Amazon Simple Queue Service
+  [ChangeMessageVisibilityBatch](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/API_ChangeMessageVisibilityBatch.html)dans la référence de l'API Amazon Simple Queue Service

# Utilisation des files d'attente de lettres mortes dans Amazon SQS
<a name="examples-sqs-dead-letter-queues"></a>

Amazon SQS fournit une assistance pour les files d'attente *lettre morte*. Une file d'attente de lettres mortes est une file que d'autres files d'attente peuvent cibler pour les messages qui ne peuvent pas être traités correctement. Vous pouvez mettre de côté et isoler ces messages dans la file d'attente de lettres mortes pour déterminer pourquoi leur traitement a échoué.

Pour créer une file d'attente lettre morte, vous devez d'abord créer une *politique de redrive*, puis définir cette politique dans les attributs de la file d'attente.

**Important**  
Une file d'attente en lettres mortes doit être du même type (FIFO ou standard) que la file source. Il doit également être créé à l'aide de la même file d'attente Compte AWS et de Région AWS celle de la file source.

## 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).

## Création d'une politique de redrive
<a name="sqs-dead-letter-queue-create-redrive-policy"></a>

Une politique de redrive est spécifiée en JSON. Pour le créer, vous pouvez utiliser la classe utilitaire JSON fournie avec le AWS SDK pour C\$1\$1.

Voici un exemple de fonction qui crée une politique de redrive en lui fournissant l'ARN de votre file d'attente de lettres mortes et le nombre maximum de fois que le message peut être reçu et non traité avant d'être envoyé dans la file d'attente de lettres mortes.

 **Comprend** 

```
#include <aws/core/Aws.h>
#include <aws/core/utils/json/JsonSerializer.h>
```

 **Code** 

```
Aws::String MakeRedrivePolicy(const Aws::String &queueArn, int maxReceiveCount) {
    Aws::Utils::Json::JsonValue redrive_arn_entry;
    redrive_arn_entry.AsString(queueArn);

    Aws::Utils::Json::JsonValue max_msg_entry;
    max_msg_entry.AsInteger(maxReceiveCount);

    Aws::Utils::Json::JsonValue policy_map;
    policy_map.WithObject("deadLetterTargetArn", redrive_arn_entry);
    policy_map.WithObject("maxReceiveCount", max_msg_entry);

    return policy_map.View().WriteReadable();
}
```

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

## Définissez la politique de redrive sur votre file d'attente source
<a name="sqs-dead-letter-queue-set-redrive-policy"></a>

Pour terminer la configuration de votre file d'attente de lettres mortes, appelez la SQSClient fonction `SetQueueAttributes` membre de la classe avec un [SetQueueAttributesRequest](https://docs.aws.amazon.com/sdk-for-cpp/latest/api/aws-cpp-sdk-sqs/html/class_aws_1_1_s_q_s_1_1_model_1_1_set_queue_attributes_request.html)objet dont vous avez défini l'`RedrivePolicy`attribut avec votre politique de redrive JSON.

 **Comprend** 

```
#include <aws/sqs/SQSClient.h>
#include <aws/sqs/model/SetQueueAttributesRequest.h>
#include <iostream>
```

 **Code** 

```
    Aws::SQS::Model::SetQueueAttributesRequest request;
    request.SetQueueUrl(srcQueueUrl);
    request.AddAttributes(
            Aws::SQS::Model::QueueAttributeName::RedrivePolicy,
            redrivePolicy);

    const Aws::SQS::Model::SetQueueAttributesOutcome outcome =
            sqsClient.SetQueueAttributes(request);
    if (outcome.IsSuccess()) {
        std::cout << "Successfully set dead letter queue for queue  " <<
                  srcQueueUrl << " to " << deadLetterQueueARN << std::endl;
    }
    else {
        std::cerr << "Error setting dead letter queue for queue " <<
                  srcQueueUrl << ": " << outcome.GetError().GetMessage() <<
                  std::endl;
    }
```

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

## Plus d'informations
<a name="more-info"></a>
+  [Utilisation des files d'attente « Dead Letter » d'Amazon SQS dans le guide du développeur Amazon Simple Queue](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/sqs-dead-letter-queues.html) Service
+  [SetQueueAttributes](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/API_SetQueueAttributes.html)dans la référence de l'API Amazon Simple Queue Service