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

# Esempi guidati per chiamare Servizi AWS utilizzando l' AWS SDK for C\$1\$1
<a name="programming-services"></a>

Se sei nuovo AWS o conosci gli esempi di AWS codice, ti consigliamo di iniziare con[Guida introduttiva agli esempi di codice](getting-started-code-examples.md).

Il codice sorgente che mostra come utilizzare i AWS servizi che utilizzano il AWS SDK per C\$1\$1 è disponibile nel [Esempi di codice](cpp_code_examples.md) capitolo di questa guida o direttamente nel [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code) su GitHub. 

Questa sezione seleziona diversi AWS servizi e illustra gli esempi in cui vengono utilizzati. I seguenti esempi guidati sono un sottoinsieme di ciò che è disponibile su Github.


**Esempi di servizi con spiegazioni aggiuntive (vedi [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code) per l'elenco completo)**  

| Servizio | Riepilogo di ciò che il servizio fornisce al programma | 
| --- | --- | 
| [Amazon CloudWatch](examples-cloudwatch.md) | Raccoglie e monitora le metriche relative AWS alle risorse in uso | 
| [Amazon DynamoDB](examples-dynamodb.md) | Un servizio di database NoSQL | 
| [Amazon Elastic Compute Cloud (Amazon EC2)](examples-ec2.md) | Capacità di elaborazione sicura e ridimensionabile | 
| [Amazon Simple Storage Service (Amazon S3)](examples-s3.md) | Archiviazione e recupero dei dati (oggetti in bucket) | 
| [Amazon Simple Queue Service (Amazon SQS)](examples-sqs.md) | Servizio di accodamento dei messaggi per inviare, archiviare e ricevere messaggi tra componenti software | 

Sono disponibili anche esempi che mostrano come utilizzare i metodi [asincroni](async-methods.md).

Per proporre un nuovo esempio di codice al team di AWS documentazione, consulta le [linee guida GitHub per](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/CONTRIBUTING.md) la creazione di una nuova richiesta. Il team preferisce creare esempi di codice che mostrino scenari ampi piuttosto che singole chiamate API.

**Utilizzo degli esempi di codice in Windows**

Se stai creando gli esempi su Windows con la versione SDK 1.9, vedi[Risoluzione dei problemi di compilazione di AWS SDK for C\$1\$1](troubleshooting-cmake.md).

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

Amazon CloudWatch (CloudWatch) è un servizio di monitoraggio per le risorse AWS cloud e le applicazioni su cui esegui AWS. Puoi usare i seguenti esempi per programmare [CloudWatch](https://aws.amazon.com/cloudwatch)usando AWS SDK per C\$1\$1.

Amazon CloudWatch monitora AWS le tue risorse e le applicazioni su cui esegui AWS in tempo reale. Puoi utilizzarlo CloudWatch per raccogliere e tenere traccia delle metriche, che sono variabili che puoi misurare per le tue risorse e applicazioni. CloudWatchgli allarmi inviano notifiche o apportano automaticamente modifiche alle risorse che stai monitorando in base a regole da te definite.

Per ulteriori informazioni CloudWatch, consulta la [Amazon CloudWatch User Guide](https://docs.aws.amazon.com/AmazonCloudWatch/latest/DeveloperGuide/).

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

**Topics**
+ [Ottenere metriche da CloudWatch](examples-cloudwatch-get-metrics.md)
+ [Pubblicazione di dati dei parametri personalizzati](examples-cloudwatch-publish-custom-metrics.md)
+ [Lavorare con gli CloudWatch allarmi](examples-cloudwatch-create-alarms.md)
+ [Utilizzo delle azioni di allarme in CloudWatch](examples-cloudwatch-use-alarm-actions.md)
+ [Invio di eventi a CloudWatch](examples-cloudwatch-send-events.md)

# Ottenere metriche da CloudWatch
<a name="examples-cloudwatch-get-metrics"></a>

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

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

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

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

## Elencazione dei parametri
<a name="listing-metrics"></a>

Per elencare CloudWatch le metriche, crea una [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)funzione e chiama. CloudWatchClient `ListMetrics` Puoi utilizzare `ListMetricsRequest` per filtrare i parametri restituiti in base a spazio dei nomi, nome parametro o dimensioni.

**Nota**  
Un elenco di metriche e dimensioni pubblicate dai AWS servizi è disponibile nell'[Amazon CloudWatch Metrics and Dimensions Reference](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/CW_Support_For_AWS.html) nella Amazon CloudWatch User Guide.

 **Include** 

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

 **Codice** 

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

Le metriche vengono restituite in 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)chiamando la relativa `GetMetrics` funzione. I risultati possono essere *paginati*. Per recuperare il successivo batch di risultati, chiamate `SetNextToken` l'oggetto di richiesta originale con il valore restituito dalla `GetNextToken` funzione dell'`ListMetricsResult`oggetto e passate l'oggetto di richiesta modificato a un'altra chiamata a. `ListMetrics`

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

## Ulteriori informazioni
<a name="more-information"></a>
+  [ListMetrics](https://docs.aws.amazon.com/AmazonCloudWatch/latest/APIReference/ListMetrics.html)nell'Amazon CloudWatch API Reference.

# Pubblicazione di dati dei parametri personalizzati
<a name="examples-cloudwatch-publish-custom-metrics"></a>

Alcuni AWS servizi pubblicano [le proprie metriche](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/aws-namespaces.html) in namespace che iniziano con `AWS/` Puoi anche pubblicare dati metrici personalizzati utilizzando il tuo spazio dei nomi (purché non inizi con). `AWS/`

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

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

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

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

## Pubblicare dati dei parametri personalizzati
<a name="publish-custom-metric-data"></a>

Per pubblicare i tuoi dati metrici, chiama la `PutMetricData` funzione CloudWatchClient's con a. [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) `PutMetricDataRequest`Devono includere lo spazio dei nomi personalizzato da utilizzare per i dati e le informazioni sul punto dati stesso in un oggetto. [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)

**Nota**  
Non è possibile specificare uno spazio dei nomi che inizia con. `AWS/` I namespace che iniziano con `AWS/` sono riservati all'uso dei prodotti Amazon Web Services.

 **Include** 

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

 **Codice** 

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

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

## Ulteriori informazioni
<a name="more-information"></a>
+  [Utilizzo di Amazon CloudWatch Metrics](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/working_with_metrics.html) nella Amazon CloudWatch User Guide.
+  [AWS Namespace](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/aws-namespaces.html) nella Amazon CloudWatch User Guide.
+  [PutMetricData](https://docs.aws.amazon.com/AmazonCloudWatch/latest/APIReference/PutMetricData.html)nell'Amazon CloudWatch API Reference.

# Lavorare con gli CloudWatch allarmi
<a name="examples-cloudwatch-create-alarms"></a>

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

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

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

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

## Creazione di un allarme
<a name="create-an-alarm"></a>

Per creare un allarme in base a una CloudWatch metrica, chiama la `PutMetricAlarm` funzione CloudWatchClient's inserendo un campo con [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)le condizioni di allarme.

 **Include** 

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

 **Codice** 

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

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

## Elencare allarmi
<a name="list-alarms"></a>

Per elencare gli CloudWatch allarmi che hai creato, chiama la `DescribeAlarms` funzione CloudWatchClient's con una [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)che puoi usare per impostare le opzioni per il risultato.

 **Include** 

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

 **Codice** 

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

L'elenco degli allarmi può essere ottenuto chiamando `getMetricAlarms` il comando [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)che viene restituito da`DescribeAlarms`.

I risultati possono essere *paginati*. Per recuperare il successivo batch di risultati, chiamate `SetNextToken` l'oggetto di richiesta originale con il valore restituito dalla `GetNextToken` funzione dell'`DescribeAlarmsResult`oggetto e passate l'oggetto di richiesta modificato a un'altra chiamata a. `DescribeAlarms`

**Nota**  
Puoi anche recuperare gli allarmi per una metrica specifica utilizzando la funzione's. CloudWatchClient `DescribeAlarmsForMetric` L'uso è simile a `DescribeAlarms`.

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

## Elimina allarmi
<a name="delete-alarms"></a>

Per eliminare gli CloudWatch allarmi, chiama la `DeleteAlarms` funzione CloudWatchClient's con una [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)contenente uno o più nomi di allarmi che desideri eliminare.

 **Include** 

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

 **Codice** 

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

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

## Ulteriori informazioni
<a name="more-information"></a>
+  [Creazione di Amazon CloudWatch Alarms](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/AlarmThatSendsEmail.html) nella Amazon CloudWatch User Guide
+  [PutMetricAlarm](https://docs.aws.amazon.com/AmazonCloudWatch/latest/APIReference/PutMetricAlarm.html)nell'Amazon CloudWatch API Reference
+  [DescribeAlarms](https://docs.aws.amazon.com/AmazonCloudWatch/latest/APIReference/DescribeAlarms.html)nell'Amazon CloudWatch API Reference
+  [DeleteAlarms](https://docs.aws.amazon.com/AmazonCloudWatch/latest/APIReference/DeleteAlarms.html)nell'Amazon CloudWatch API Reference

# Utilizzo delle azioni di allarme in CloudWatch
<a name="examples-cloudwatch-use-alarm-actions"></a>

Utilizzando le azioni di CloudWatch allarme, puoi creare allarmi che eseguono azioni come l'arresto, la chiusura, il riavvio o il ripristino automatico delle istanze Amazon EC2.

[Le azioni di allarme possono essere aggiunte a un allarme utilizzando la funzione «s» durante la creazione di un allarme. [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)`SetAlarmActions`](examples-cloudwatch-create-alarms.md)

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

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

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

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

## Attivare le operazioni di allarme
<a name="enable-alarm-actions"></a>

Per abilitare le azioni di allarme per un CloudWatch allarme, chiama CloudWatchClient th's `EnableAlarmActions` con un nome [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)contenente uno o più nomi di allarmi di cui desideri abilitare le azioni.

 **Include** 

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

 **Codice** 

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

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

## Disattivare le operazioni di allarme
<a name="disable-alarm-actions"></a>

Per disabilitare le azioni di CloudWatch allarme relative a un allarme, chiama CloudWatchClient th's `DisableAlarmActions` con un nome [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)contenente uno o più nomi di allarmi di cui desideri disabilitare le azioni.

 **Include** 

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

 **Codice** 

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

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

## Ulteriori informazioni
<a name="more-information"></a>
+  [Crea allarmi per interrompere, terminare, riavviare o ripristinare un'istanza](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/UsingAlarmActions.html) nella Amazon User Guide CloudWatch 
+  [PutMetricAlarm](https://docs.aws.amazon.com/AmazonCloudWatch/latest/APIReference/PutMetricAlarm.html)nell'Amazon CloudWatch API Reference
+  [EnableAlarmActions](https://docs.aws.amazon.com/AmazonCloudWatch/latest/APIReference/EnableAlarmActions.html)nell'Amazon CloudWatch API Reference
+  [DisableAlarmActions](https://docs.aws.amazon.com/AmazonCloudWatch/latest/APIReference/DisableAlarmActions.html)nell'Amazon CloudWatch API Reference

# Invio di eventi a CloudWatch
<a name="examples-cloudwatch-send-events"></a>

CloudWatch Events offre un flusso quasi in tempo reale di eventi di sistema che descrivono le modifiche nelle AWS risorse alle istanze Amazon EC2, alle funzioni Lambda, ai flussi Kinesis, alle attività di Amazon ECS, alle macchine a stati Step Functions, agli argomenti di Amazon SNS, alle code Amazon SQS o alle destinazioni integrate. Puoi abbinare gli eventi e instradarli verso una o più funzioni o stream target utilizzando regole semplici.

**Nota**  
[Questi frammenti di codice presuppongono che tu abbia compreso il materiale contenuto in [Getting Started Using AWS SDK per C\$1\$1 e che tu abbia configurato le credenziali predefinite utilizzando le informazioni](getting-started.md) contenute in Providing Credentials. AWSAWS](credentials.md)

## Aggiunta di eventi
<a name="add-events"></a>

Per aggiungere CloudWatch eventi personalizzati, chiama la `PutEvents` funzione CloudWatchEventsClient th's con 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)oggetto che contiene uno o più [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)oggetti che forniscono dettagli su ciascun evento. Puoi specificare diversi parametri per la voce, ad esempio l'origine e il tipo di evento, le risorse associate all'evento e così via.

**Nota**  
Puoi specificare un massimo di 10 eventi per chiamata a `putEvents`.

 **Include** 

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

 **Codice** 

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

## Aggiunta di regole
<a name="add-rules"></a>

Per creare o aggiornare una regola, chiama la `PutRule` funzione CloudWatchEventsClient's con a [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)con il nome della regola e parametri opzionali come il [modello di evento](https://docs.aws.amazon.com/AmazonCloudWatch/latest/events/CloudWatchEventsandEventPatterns.html), il ruolo IAM da associare alla regola e un'[espressione di pianificazione](https://docs.aws.amazon.com/AmazonCloudWatch/latest/events/ScheduledEvents.html) che descriva la frequenza con cui viene eseguita la regola.

 **Include** 

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

 **Codice** 

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

## Aggiunta di target
<a name="add-targets"></a>

I target sono le risorse che vengono invocate quando una regola viene attivata. Gli obiettivi di esempio includono istanze Amazon EC2, funzioni Lambda, flussi Kinesis, attività Amazon ECS, macchine a stati Step Functions e destinazioni integrate.

Per aggiungere un obiettivo a una regola, chiama la `PutTargets` funzione CloudWatchEventsClient th's con un messaggio [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)contenente la regola da aggiornare e un elenco di obiettivi da aggiungere alla regola.

 **Include** 

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

 **Codice** 

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

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

## Ulteriori informazioni
<a name="more-information"></a>
+  [Aggiungere eventi con PutEvents](https://docs.aws.amazon.com/AmazonCloudWatch/latest/events/AddEventsPutEvents.html) la Amazon CloudWatch Events User Guide
+  [Pianifica le espressioni per le regole](https://docs.aws.amazon.com/AmazonCloudWatch/latest/events/ScheduledEvents.html) nella Guida per l'utente di Amazon CloudWatch Events
+  [Tipi di CloudWatch eventi per gli eventi](https://docs.aws.amazon.com/AmazonCloudWatch/latest/events/EventTypes.html) nella Guida per l'utente di Amazon CloudWatch Events
+  [Eventi e modelli di eventi](https://docs.aws.amazon.com/AmazonCloudWatch/latest/events/CloudWatchEventsandEventPatterns.html) nella Guida per l'utente di Amazon CloudWatch Events
+  [PutEvents](https://docs.aws.amazon.com/AmazonCloudWatchEvents/latest/APIReference/PutEvents.html)nel riferimento all'API di riferimento di Amazon CloudWatch Events
+  [PutTargets](https://docs.aws.amazon.com/AmazonCloudWatchEvents/latest/APIReference/PutTargets.html)nel riferimento all'API di riferimento di Amazon CloudWatch Events
+  [PutRule](https://docs.aws.amazon.com/AmazonCloudWatchEvents/latest/APIReference/PutRule.html)nel riferimento all'API di riferimento di Amazon CloudWatch Events

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

Amazon DynamoDB è un servizio di database NoSQL interamente gestito che combina prestazioni elevate e prevedibili con una scalabilità ottimale. Gli esempi seguenti mostrano come programmare [Amazon DynamoDB](https://aws.amazon.com/dynamodb) utilizzando. AWS SDK per C\$1\$1

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

**Topics**
+ [Lavorare con le tabelle in DynamoDB](examples-dynamodb-tables.md)
+ [Lavorare con gli elementi in DynamoDB](examples-dynamodb-items.md)

# Lavorare con le tabelle in DynamoDB
<a name="examples-dynamodb-tables"></a>

Le tabelle sono i contenitori per tutti gli elementi di un database DynamoDB. Prima di poter aggiungere o rimuovere dati da DynamoDB, è necessario creare una tabella.

Per ogni tabella, devi definire:
+ Un *nome* di tabella unico per il tuo Account AWS e. Regione AWS
+ Una *chiave primaria* per la quale ogni valore deve essere unico. Due elementi della tabella non possono avere lo stesso valore di chiave primaria.

  La chiave primaria può essere *semplice*, costituita da una singola chiave di partizione (HASH), o *composita*, costituita da una chiave di partizione e una di ordinamento (RANGE).

  A ogni valore chiave è associato un *tipo di dati*, enumerato dalla classe. [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) Il valore della chiave può essere binario (B), numerico (N) o una stringa (S). Per ulteriori informazioni, consulta [Regole di denominazione e tipi di dati](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/HowItWorks.NamingRulesDataTypes.html) nella Amazon DynamoDB Developer Guide.
+  Valori di *throughput assegnati* che definiscono il numero di unità di read/write capacità riservate per la tabella.
**Nota**  
 Poiché i [prezzi di Amazon DynamoDB](https://aws.amazon.com/dynamodb/pricing/) sono basati sui valori del throughput assegnato che vengono impostati sulle tabelle, ti consigliamo di prenotare solo la capacità che ritieni occorra per la tabella.  
Il throughput assegnato per una tabella può essere modificato in qualsiasi momento, in modo da poter regolare la capacità se le esigenze cambiano.

## Creazione di una tabella
<a name="dynamodb-create-table"></a>

Utilizzate il metodo `CreateTable` 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) per creare una nuova tabella DynamoDB. È necessario costruire gli attributi della tabella e uno schema della tabella, entrambi utilizzati per identificare la chiave primaria della tabella. È inoltre necessario fornire i valori di throughput iniziali assegnati e un nome di tabella. `CreateTable`è un'operazione asincrona. `GetTableStatus`restituirà CREATING finché la tabella non sarà ATTIVA e pronta per l'uso.

### Creazione di una tabella con una chiave primaria semplice
<a name="dynamodb-create-table-simple"></a>

Questo codice consente di creare una tabella con una chiave primaria semplice ("Name").

 **Include** 

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

 **Codice** 

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

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

### Creazione di una tabella con una chiave primaria composita
<a name="dynamodb-create-table-composite"></a>

Aggiungi un altro [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)e [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)a [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).

 **Include** 

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

 **Codice** 

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

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

## Elencare tabelle
<a name="dynamodb-list-tables"></a>

È possibile elencare le tabelle in una particolare regione chiamando il metodo 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)`ListTables`.

 **Include** 

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

 **Codice** 

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

Per impostazione predefinita, vengono restituite fino a 100 tabelle per chiamata. `GetExclusiveStartTableName`Utilizzatela sull'[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)oggetto restituito per ottenere l'ultima tabella valutata. Puoi utilizzare questo valore per avviare la visualizzazione dell'elenco dopo l'ultimo valore restituito dalla visualizzazione dell'elenco precedente.

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

## Recupera informazioni su una tabella
<a name="dynamodb-describe-table"></a>

Puoi scoprire di più su una tabella chiamando il metodo 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)`DescribeTable`.

 **Include** 

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

 **Codice** 

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

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

## Modificare una tabella
<a name="dynamodb-update-table"></a>

[Puoi modificare i valori di throughput assegnati alla tabella in qualsiasi momento chiamando il metodo 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`

 **Include** 

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

 **Codice** 

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

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

## Eliminazione di una tabella
<a name="dynamodb-delete-table"></a>

Chiama il metodo `DeleteTable` 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) e passagli il nome della tabella.

 **Include** 

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

 **Codice** 

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

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

## Ulteriori informazioni
<a name="more-info"></a>
+  [Linee guida per l'utilizzo delle tabelle](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/GuidelinesForTables.html) nella Amazon DynamoDB Developer Guide
+  [Utilizzo delle tabelle in DynamoDB nella](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/WorkingWithTables.html) Amazon DynamoDB Developer Guide

# Lavorare con gli elementi in DynamoDB
<a name="examples-dynamodb-items"></a>

*In DynamoDB, un elemento è una raccolta *di attributi, ognuno dei* quali ha *un nome e un valore*.* Un valore attributo può essere un tipo scalare, set o documento. Per ulteriori informazioni, consulta [Regole di denominazione e tipi di dati](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/HowItWorks.NamingRulesDataTypes.html) nella Amazon DynamoDB Developer Guide.

## Recupera un elemento da una tabella
<a name="dynamodb-get-item"></a>

Chiama il metodo [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)`GetItem`. Passagli 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)oggetto con il nome della tabella e il valore della chiave primaria dell'elemento che desideri. Restituisce 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)oggetto.

È possibile utilizzare il `GetItem()` metodo dell'`GetItemResult`oggetto restituito per recuperare una `Aws::Map` delle [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)coppie di chiavi `Aws::String` e valori associate all'elemento.

 **Include** 

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

 **Codice** 

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

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

## Aggiungere un elemento a una tabella
<a name="dynamodb-add-item"></a>

Crea [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)coppie di chiavi `Aws::String` e valori che rappresentino ogni elemento. Queste devono includere valori per i campi chiave primaria della tabella. Se l'elemento identificato dalla chiave primaria esiste già, i relativi campi vengono *aggiornati* dalla richiesta. Aggiungili all'[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)utilizzo del `AddItem` metodo.

 **Include** 

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

 **Codice** 

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

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

## Aggiornamento di un item esistente in una tabella
<a name="dynamodb-update-item"></a>

È possibile aggiornare un attributo per un elemento già esistente in una tabella utilizzando il `UpdateItem` metodo di DBClient Dynamo, fornendo un nome di tabella, un valore della chiave primaria e i campi da aggiornare e il valore corrispondente.

 **Importazioni** 

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

 **Codice** 

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

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

## Ulteriori informazioni
<a name="more-info"></a>
+  [Linee guida per l'utilizzo degli elementi](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/GuidelinesForItems.html) nella Amazon DynamoDB Developer Guide
+  [Utilizzo degli elementi in DynamoDB nella](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/WorkingWithItems.html) Amazon DynamoDB Developer Guide

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

Amazon Elastic Compute Cloud (Amazon EC2) Elastic Compute Cloud (Amazon EC2) è un servizio Web che fornisce una capacità di calcolo ridimensionabile, letteralmente server nei data center di Amazon, che usi per creare e ospitare i tuoi sistemi software. Puoi utilizzare i seguenti esempi per programmare [Amazon EC2](https://aws.amazon.com/ec2) utilizzando. AWS SDK per C\$1\$1

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

**Topics**
+ [Gestione delle istanze Amazon EC2](examples-ec2-instances.md)
+ [Utilizzo di indirizzi IP elastici in Amazon EC2](examples-ec2-elastic-ip.md)
+ [Utilizzo di regioni e zone di disponibilità per Amazon EC2](examples-ec2-regions-zones.md)
+ [Utilizzo delle coppie di chiavi di Amazon EC2](examples-ec2-key-pairs.md)
+ [Utilizzo dei gruppi di sicurezza in Amazon EC2](examples-ec2-security-groups.md)

# Gestione delle istanze Amazon EC2
<a name="examples-ec2-instances"></a>

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

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

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

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

## Creazione di un'istanza
<a name="create-an-instance"></a>

Crea una nuova istanza Amazon EC2 chiamando la `RunInstances` funzione del EC2 Client, fornendogli una Amazon Machine Image (AMI) [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)contenente l'[Amazon Machine Image (AMI)](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/AMIs.html) da utilizzare e un tipo di [istanza](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/instance-types.html).

 **Include** 

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

 **Codice** 

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

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

## Avvia un'istanza
<a name="start-an-instance"></a>

Per avviare un'istanza Amazon EC2, chiama la `StartInstances` funzione del EC2 Client, fornendogli un file [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)contenente l'ID dell'istanza da avviare.

 **Include** 

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

 **Codice** 

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

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

## Interrompi un'istanza
<a name="stop-an-instance"></a>

Per interrompere un'istanza Amazon EC2, chiama la `StopInstances` funzione del EC2 Client, fornendole un file [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)contenente l'ID dell'istanza da interrompere.

 **Include** 

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

 **Codice** 

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

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

## Riavviare un'istanza
<a name="reboot-an-instance"></a>

Per riavviare un'istanza Amazon EC2, chiama EC2 la funzione `RebootInstances` del Client, fornendole [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)un file contenente l'ID dell'istanza da riavviare.

 **Include** 

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

 **Codice** 

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

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

## Descrizione delle istanze
<a name="describe-instances"></a>

Per elencare le tue istanze, crea una `DescribeInstances` funzione del EC2 Client [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)e richiamala. Restituirà 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)oggetto che puoi utilizzare per elencare le istanze Amazon EC2 per il tuo and. Account AWS Regione AWS

Le istanze sono raggruppate in base alla *prenotazione*. Ogni prenotazione corrisponde alla chiamata a `StartInstances` che ha avviato l'istanza. Per elencare le tue istanze, devi prima chiamare la `GetReservations` funzione della `DescribeInstancesResponse` classe e poi chiamare ogni oggetto Reservation `getInstances` restituito.

 **Include** 

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

 **Codice** 

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

I risultati vengono visualizzati in pagine; è possibile ottenere ulteriori risultati passando il valore restituito dalla `GetNextToken` funzione dell'oggetto risultato alla `SetNextToken` funzione dell'oggetto di richiesta originale, quindi utilizzando lo stesso oggetto di richiesta nella chiamata successiva a`DescribeInstances`.

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

## Abilita il monitoraggio delle istanze
<a name="enable-instance-monitoring"></a>

Puoi monitorare vari aspetti delle tue istanze Amazon EC2, come l'utilizzo della CPU e della rete, la memoria disponibile e lo spazio su disco residuo. Per ulteriori informazioni sul monitoraggio delle istanze, consulta [Monitoring Amazon EC2](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/monitoring_ec2.html) nella Amazon EC2 User Guide.

Per iniziare a monitorare un'istanza, devi crearne un'istanza [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)con l'ID dell'istanza da monitorare e passarla alla funzione del EC2 `MonitorInstances` Client.

 **Include** 

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

 **Codice** 

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

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

## Disattiva il monitoraggio delle istanze
<a name="disable-instance-monitoring"></a>

Per interrompere il monitoraggio di un'istanza, [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)creane un'istanza con l'ID dell'istanza per interrompere il monitoraggio e passala alla `UnmonitorInstances` funzione del EC2 Client.

 **Include** 

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

 **Codice** 

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

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

## Ulteriori informazioni
<a name="more-information"></a>
+  [RunInstances](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_RunInstances.html)nel riferimento alle API di Amazon EC2
+  [DescribeInstances](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_DescribeInstances.html)nel riferimento alle API di Amazon EC2
+  [StartInstances](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_StartInstances.html)nel riferimento alle API di Amazon EC2
+  [StopInstances](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_StopInstances.html)nel riferimento alle API di Amazon EC2
+  [RebootInstances](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_RebootInstances.html)nel riferimento alle API di Amazon EC2
+  [DescribeInstances](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_DescribeInstances.html)nel riferimento alle API di Amazon EC2
+  [MonitorInstances](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_MonitorInstances.html)nel riferimento alle API di Amazon EC2
+  [UnmonitorInstances](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_UnmonitorInstances.html)nel riferimento alle API di Amazon EC2

# Utilizzo di indirizzi IP elastici in Amazon EC2
<a name="examples-ec2-elastic-ip"></a>

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

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

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

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

## Alloca un indirizzo IP elastico
<a name="allocate-an-elastic-ip-address"></a>

Per utilizzare un indirizzo IP elastico bisogna prima allocarne uno al proprio account e associarlo con la propria istanza o con un'interfaccia di rete.

Per allocare un indirizzo IP elastico, chiama la `AllocateAddress` funzione del EC2 client con 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)oggetto contenente il tipo di rete (EC2 classico o VPC). 

**avvertimento**  
Ritireremo EC2-Classic il 15 agosto 2022. Suggeriamo di effettuare la migrazione da EC2-Classic a un VPC. [Per ulteriori informazioni, consulta **Migrare da EC2-Classic a un VPC** nella Amazon EC2 User Guide for Linux [Instances o nella Amazon EC2 User Guide for Windows Instances](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/vpc-migrate.html).](https://docs.aws.amazon.com/AWSEC2/latest/WindowsGuide/vpc-migrate.html) Per ulteriori informazioni, consulta il post di blog [Il networking EC2-Classic va in pensione: ecco come prepararsi](https://aws.amazon.com/blogs/aws/ec2-classic-is-retiring-heres-how-to-prepare/).

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 nell'oggetto di risposta contiene un ID di allocazione che è possibile utilizzare per associare l'indirizzo a un'istanza, passando l'ID di allocazione e l'ID dell'istanza in a alla funzione del client. [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) EC2`AssociateAddress`

 **Include** 

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

 **Codice** 

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

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

## Descrivere gli indirizzi IP elastici
<a name="describe-elastic-ip-addresses"></a>

Per elencare gli indirizzi IP elastici assegnati al tuo account, chiama la `DescribeAddresses` funzione EC2 Client. Restituisce un oggetto risultato che contiene un oggetto [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)che puoi utilizzare per ottenere un elenco di oggetti [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) che rappresentano gli indirizzi IP elastici sul tuo account.

 **Include** 

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

 **Codice** 

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

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

## Rilasciare un indirizzo IP elastico
<a name="release-an-elastic-ip-address"></a>

Per rilasciare un indirizzo IP elastico, chiama la `ReleaseAddress` funzione del EC2 Client, passandole un indirizzo [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)contenente l'ID di allocazione dell'indirizzo IP elastico che desideri rilasciare.

 **Include** 

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

 **Codice** 

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

Dopo aver rilasciato un indirizzo IP elastico, questo viene rilasciato nel pool di indirizzi AWS IP e in seguito potrebbe non essere più disponibile. Assicurati di aggiornare i record DNS e gli eventuali server o dispositivi che comunicano con l'indirizzo. Se tenti di rilasciare un indirizzo IP elastico che hai già rilasciato, riceverai un *AuthFailure*errore se l'indirizzo è già assegnato a un altro AWS account.

Se utilizzi un *VPC predefinito*, il rilascio di un indirizzo IP elastico lo dissocia automaticamente da qualsiasi istanza a cui è associato. Per dissociare un indirizzo IP elastico senza rilasciarlo, utilizza la funzione del Client. EC2 `DisassociateAddress`

Se utilizzi un VPC non di default, *devi* utilizzare `DisassociateAddress` per disassociare l'indirizzo IP elastico prima di provare a rilasciarlo. *Altrimenti, Amazon EC2 restituisce un errore (non valido. IPAddress InUse*).

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

## Ulteriori informazioni
<a name="more-information"></a>
+  [Indirizzi IP elastici](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/elastic-ip-addresses-eip.html) nella Guida per l'utente di Amazon EC2
+  [AllocateAddress](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_AllocateAddress.html)nel riferimento alle API di Amazon EC2
+  [DescribeAddresses](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_DescribeAddresses.html)nel riferimento alle API di Amazon EC2
+  [ReleaseAddress](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_ReleaseAddress.html)nel riferimento alle API di Amazon EC2

# Utilizzo di regioni e zone di disponibilità per Amazon EC2
<a name="examples-ec2-regions-zones"></a>

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

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

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

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

## Descrivere le regioni
<a name="describe-regions"></a>

Per elencare Regioni AWS quelle disponibili Account AWS, chiama la `DescribeRegions` funzione del EC2 Client con 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).

Riceverai un oggetto [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)nel risultato. Chiama la sua `GetRegions` funzione per ottenere un elenco di oggetti [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) che rappresentano ciascuna Regione.

 **Include** 

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

 **Codice** 

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

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

## Descrivere le zone di disponibilità
<a name="describe-availability-zones"></a>

Per elencare ogni zona di disponibilità disponibile per il tuo account, chiama la `DescribeAvailabilityZones` funzione EC2 Client con 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).

Riceverai un [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)nell'oggetto del risultato. Chiama la sua `GetAvailabilityZones` funzione per ottenere un elenco di [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)oggetti che rappresentano ogni zona di disponibilità.

 **Include** 

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

 **Codice** 

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

    }
```

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

## Ulteriori informazioni
<a name="more-information"></a>
+  [Regioni e zone di disponibilità](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/using-regions-availability-zones.html) nella Guida per l'utente di Amazon EC2
+  [DescribeRegions](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_DescribeRegions.html)nel riferimento alle API di Amazon EC2
+  [DescribeAvailabilityZones](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_DescribeAvailabilityZones.html)nel riferimento alle API di Amazon EC2

# Utilizzo delle coppie di chiavi di Amazon EC2
<a name="examples-ec2-key-pairs"></a>

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

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

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

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

## Crea una coppia di chiavi
<a name="create-a-key-pair"></a>

Per creare una coppia di chiavi, chiama la `CreateKeyPair` funzione del EC2 Client con una [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)che contenga il nome della chiave.

 **Include** 

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

 **Codice** 

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

    }
```

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

## Descrivere coppie di chiavi
<a name="describe-key-pairs"></a>

Per elencare le tue coppie di chiavi o per ottenere informazioni su di esse, chiama la `DescribeKeyPairs` funzione del EC2 Client con 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).

Ne riceverai una [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)che potrai usare per accedere all'elenco delle coppie di tasti chiamando la sua `GetKeyPairs` funzione, che restituisce un elenco di [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)oggetti.

 **Include** 

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

 **Codice** 

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

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

## Eliminare una coppia di chiavi
<a name="delete-a-key-pair"></a>

Per eliminare una coppia di chiavi, chiama la `DeleteKeyPair` funzione del EC2 Client, passandole una [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)che contiene il nome della coppia di chiavi da eliminare.

 **Include** 

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

 **Codice** 

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

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

## Ulteriori informazioni
<a name="more-information"></a>
+  [Coppie di chiavi Amazon EC2 nella Guida](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-key-pairs.html) per l'utente di Amazon EC2
+  [CreateKeyPair](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_CreateKeyPair.html)nel riferimento alle API di Amazon EC2
+  [DescribeKeyPairs](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_DescribeKeyPairs.html)nel riferimento alle API di Amazon EC2
+  [DeleteKeyPair](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_DeleteKeyPair.html)nel riferimento alle API di Amazon EC2

# Utilizzo dei gruppi di sicurezza in Amazon EC2
<a name="examples-ec2-security-groups"></a>

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

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

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

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

## Crea un gruppo di sicurezza
<a name="create-a-security-group"></a>

Per creare un gruppo di sicurezza, chiama la `CreateSecurityGroup` funzione del EC2 Client con una [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)che contenga il nome della chiave.

 **Include** 

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

 **Codice** 

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

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

## Configurare un gruppo di sicurezza
<a name="configure-a-security-group"></a>

Un gruppo di sicurezza può controllare sia il traffico in entrata (ingresso) che quello in uscita (uscita) verso le istanze Amazon EC2.

Per aggiungere regole di ingresso al tuo gruppo di sicurezza, utilizza la `AuthorizeSecurityGroupIngress` funzione EC2 Client, fornendo il nome del gruppo di sicurezza e le regole di accesso ([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)) che desideri assegnargli all'interno di un oggetto. [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) Nell'esempio seguente viene mostrato come aggiungere autorizzazioni IP a un gruppo di sicurezza.

 **Include** 

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

 **Codice** 

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

Per aggiungere una regola di uscita al gruppo di sicurezza, fornisci dati simili in e [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)alla `AuthorizeSecurityGroupEgress` funzione del EC2 Client.

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

## Descrivere i gruppi di sicurezza
<a name="describe-security-groups"></a>

Per descrivere i tuoi gruppi di sicurezza o ottenere informazioni su di essi, chiama la `DescribeSecurityGroups` funzione del EC2 Client con 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).

Riceverai un oggetto [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)nel risultato che potrai usare per accedere all'elenco dei gruppi di sicurezza chiamando la sua `GetSecurityGroups` funzione, che restituisce un elenco di [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)oggetti.

 **Include** 

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

 **Codice** 

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

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

## Eliminare un gruppo di sicurezza
<a name="delete-a-security-group"></a>

Per eliminare un gruppo di sicurezza, chiamate la `DeleteSecurityGroup` funzione del EC2 Client, passandole una [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)che contenga l'ID del gruppo di sicurezza da eliminare.

 **Include** 

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

 **Codice** 

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

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

## Ulteriori informazioni
<a name="more-information"></a>
+  [Gruppi di sicurezza di Amazon EC2 nella guida](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-key-pairs.html) per l'utente di Amazon EC2
+  [Autorizzazione del traffico in entrata per le istanze Linux](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/authorizing-access-to-an-instance.html) nella Guida per l'utente di Amazon EC2
+  [CreateSecurityGroup](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_CreateSecurityGroup.html)nel riferimento alle API di Amazon EC2
+  [DescribeSecurityGroups](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_DescribeSecurityGroups.html)nel riferimento alle API di Amazon EC2
+  [DeleteSecurityGroup](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_DeleteSecurityGroup.html)nel riferimento alle API di Amazon EC2
+  [AuthorizeSecurityGroupIngress](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_AuthorizeSecurityGroupIngress.html)nel riferimento alle API di Amazon EC2

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

 **Codice** 

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

    auto outcome = client.ListBuckets();

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

    return result;
}
```

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

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



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

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



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

 **Codice** 

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

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

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

    return outcome.IsSuccess();
}
```

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

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



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

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



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

 **Codice**

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

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

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

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

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

    return outcome.IsSuccess();
}
```

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

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

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

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

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

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

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

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

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

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

 **Codice** 

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

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

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

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

    request.SetBody(inputData);

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

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

    return outcome.IsSuccess();
}
```

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

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

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

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

 **Codice** 

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

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

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

    request.SetBody(inputData);

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

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

    return outcome.IsSuccess();
}
```

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

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

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

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

 **Codice** 

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

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

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

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

        auto outcome = s3Client.ListObjectsV2(request);

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

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

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

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

    return true;
}
```

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

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

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

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

 **Codice** 

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

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

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

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

    return outcome.IsSuccess();
}
```

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

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

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

 **Codice** 

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

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

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

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

    return outcome.IsSuccess();
}
```

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    return outcome.IsSuccess();
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    return outcome.IsSuccess();
}

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

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

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

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

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

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

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

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

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

    return result;
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    return outcome.IsSuccess();
}

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

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

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

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

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

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

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

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

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

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

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

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

    return outcome.IsSuccess();
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

 **Codice** 

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

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

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

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

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

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

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

    return outcome.IsSuccess();
}
```

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

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

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

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

 **Codice** 

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

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

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

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

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

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

    return outcome.IsSuccess();
}
```

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

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

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

 **Codice** 

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

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

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

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

    return outcome.IsSuccess();
}
```

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

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

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

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

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

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

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

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

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

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

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

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

 **Codice** 

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

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

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

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

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

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

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

    return outcome.IsSuccess();
}
```

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

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

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

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

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

 **Codice** 

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

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

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

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

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

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

    return outcome.IsSuccess();
}
```

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

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

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

 **Codice** 

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

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

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

    return outcome.IsSuccess();
}
```

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

1. Crea l'esempio.

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

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

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

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

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

    and 

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

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

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

Amazon Simple Queue Service (Amazon SQS) è un servizio di accodamento dei messaggi completamente gestito che semplifica il disaccoppiamento e la scalabilità di microservizi, sistemi distribuiti e applicazioni serverless. Puoi utilizzare i seguenti esempi per programmare [Amazon SQS utilizzando.](https://aws.amazon.com/sqs) AWS SDK per C\$1\$1

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

**Topics**
+ [Utilizzo di Amazon SQS Message Queues](examples-sqs-message-queues.md)
+ [Invio, ricezione ed eliminazione di messaggi Amazon SQS](examples-sqs-messages.md)
+ [Abilitazione del polling lungo per le code di messaggi di Amazon SQS](examples-sqs-long-polling.md)
+ [Impostazione del timeout di visibilità in Amazon SQS](examples-sqs-visibility-timeout.md)
+ [Utilizzo delle code DLQ in Amazon SQS](examples-sqs-dead-letter-queues.md)

# Utilizzo di Amazon SQS Message Queues
<a name="examples-sqs-message-queues"></a>

Una *coda di messaggi* è il contenitore logico che usi per inviare messaggi in modo affidabile in Amazon SQS. Sono disponibili due tipi di code: *standard* e *first-in, first-out* (FIFO). Per ulteriori informazioni sulle code e sulle differenze tra questi tipi, consulta la [Amazon Simple Queue Service Developer Guide](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/).

Questi esempi in C\$1\$1 mostrano come utilizzare per creare, AWS SDK per C\$1\$1 elencare, eliminare e ottenere l'URL di una coda Amazon SQS.

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

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

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

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

## Creare una coda
<a name="sqs-create-queue"></a>

Utilizzate la funzione `CreateQueue` membro della SQSClient classe e fornitele 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)oggetto che descriva i parametri della coda.

 **Include** 

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

 **Codice** 

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

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

## Elencare code
<a name="sqs-list-queues"></a>

Per elencare le code Amazon SQS per il tuo account, chiama la funzione `ListQueues` membro della SQSClient classe e passale un oggetto. [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)

 **Include** 

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

 **Codice** 

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

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

## Ottieni l'URL della coda
<a name="sqs-get-queue-url"></a>

Per ottenere l'URL di una coda Amazon SQS esistente, chiama la funzione member della SQSClient classe`GetQueueUrl`.

 **Include** 

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

 **Codice** 

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

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

## Eliminare una coda
<a name="sqs-delete-queue"></a>

Fornisci l'[URL](#sqs-get-queue-url) della funzione `DeleteQueue` membro SQSClient della classe.

 **Include** 

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

 **Codice** 

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

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

## Ulteriori informazioni
<a name="more-info"></a>
+  [Come funzionano le code Amazon SQS nella Guida per gli sviluppatori](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/sqs-how-it-works.html) di Amazon Simple Queue Service
+  [CreateQueue](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/API_CreateQueue.html)nel riferimento all'API di riferimento di Amazon Simple Queue Service
+  [GetQueueUrl](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/API_GetQueueUrl.html)nel riferimento all'API di riferimento di Amazon Simple Queue Service
+  [ListQueues](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/API_ListQueues.html)nel riferimento all'API di riferimento di Amazon Simple Queue Service
+  [DeleteQueues](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/API_DeleteQueues.html)nel riferimento all'API di riferimento di Amazon Simple Queue Service

# Invio, ricezione ed eliminazione di messaggi Amazon SQS
<a name="examples-sqs-messages"></a>

I messaggi vengono sempre recapitati utilizzando una coda [SQS.](examples-sqs-message-queues.md) Questi esempi in C\$1\$1 mostrano come utilizzare per inviare, ricevere ed eliminare messaggi Amazon SQS dalle code SQS. AWS SDK per C\$1\$1 

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

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

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

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

## Inviare un messaggio
<a name="sqs-message-send"></a>

Puoi aggiungere un singolo messaggio a una coda Amazon SQS chiamando la funzione membro della SQSClient classe`SendMessage`. `SendMessage`Fornisci 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)oggetto contenente l'[URL](examples-sqs-message-queues.md#sqs-get-queue-url) della coda, il corpo del messaggio e un valore di ritardo opzionale (in secondi).

 **Include** 

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

 **Codice** 

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

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

## Ricevi messaggi
<a name="sqs-messages-receive"></a>

Recupera tutti i messaggi attualmente in coda chiamando la funzione `ReceiveMessage` membro della SQSClient classe, passandole l'URL della coda. I messaggi vengono restituiti come un elenco di oggetti [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).

 **Include** 

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

 **Codice** 

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

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

### Eliminare i messaggi dopo la ricezione
<a name="sqs-messages-delete"></a>

Dopo aver ricevuto un messaggio e averne elaborato il contenuto, eliminatelo dalla coda inviando l'handle di ricezione del messaggio e l'URL della coda alla funzione `DeleteMessage` membro della SQSClient classe.

 **Include** 

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

 **Codice** 

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

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

## Ulteriori informazioni
<a name="more-info"></a>
+  [Come funzionano le code Amazon SQS nella Guida per gli sviluppatori](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/sqs-how-it-works.html) di Amazon Simple Queue Service
+  [SendMessage](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/API_SendMessage.html)nel riferimento all'API di riferimento di Amazon Simple Queue Service
+  [SendMessageBatch](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/API_SendMessageBatch.html)nel riferimento all'API di riferimento di Amazon Simple Queue Service
+  [ReceiveMessage](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/API_ReceiveMessage.html)nel riferimento all'API di riferimento di Amazon Simple Queue Service
+  [DeleteMessage](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/API_DeleteMessage.html)nel riferimento all'API di riferimento di Amazon Simple Queue Service

# Abilitazione del polling lungo per le code di messaggi di Amazon SQS
<a name="examples-sqs-long-polling"></a>

Amazon SQS utilizza il *polling breve* per impostazione predefinita, interrogando solo un sottoinsieme di server, in base a una distribuzione casuale ponderata, per determinare se sono disponibili messaggi da includere nella risposta.

Il polling prolungato aiuta a ridurre i costi di utilizzo di Amazon SQS riducendo il numero di risposte vuote quando non ci sono messaggi disponibili da restituire in risposta a ReceiveMessage una richiesta inviata a una coda di Amazon SQS ed eliminando le false risposte vuote. *Puoi impostare una frequenza di polling lunga da 1 a 20 secondi.*

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

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

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

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

## Abilita il polling lungo durante la creazione di una coda
<a name="sqs-long-polling-create-queue"></a>

Per abilitare il polling lungo durante la creazione di una coda Amazon SQS, imposta `ReceiveMessageWaitTimeSeconds` l'attributo sull'oggetto prima di chiamare [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)la funzione membro SQSClient della `CreateQueue` classe.

 **Include** 

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

 **Codice** 

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

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

## Abilitazione del long polling su una coda esistente
<a name="sqs-long-polling-existing-queue"></a>

Oltre ad abilitare il polling lungo durante la creazione di una coda, puoi anche abilitarlo su una coda esistente impostando la [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)funzione «`ReceiveMessageWaitTimeSeconds`before call member» della SQSClient classe`SetQueueAttributes`.

 **Include** 

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

 **Codice** 

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

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

## Abilitazione del long polling sulla ricezione del messaggio
<a name="sqs-long-polling-receive-message"></a>

Puoi abilitare il polling prolungato quando ricevi un messaggio impostando il tempo di attesa in secondi sulla funzione ReceiveMessage membro della SQSClient classe. [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)

**Nota**  
Dovresti assicurarti che il timeout della richiesta del AWS cliente sia superiore al tempo massimo di sondaggio lungo (20 secondi) in modo che `ReceiveMessage` le tue richieste non scadano in attesa del prossimo evento di sondaggio\$1

 **Include** 

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

 **Codice** 

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

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

## Ulteriori informazioni
<a name="more-info"></a>
+  [Amazon SQS Long Polling nella Guida per gli sviluppatori di](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/sqs-long-polling.html) Amazon Simple Queue Service
+  [CreateQueue](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/API_CreateQueue.html)nel riferimento all'API di riferimento di Amazon Simple Queue Service
+  [ReceiveMessage](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/API_ReceiveMessage.html)nel riferimento all'API di riferimento di Amazon Simple Queue Service
+  [SetQueueAttributes](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/API_SetQueueAttributes.html)nel riferimento all'API di riferimento di Amazon Simple Queue Service

# Impostazione del timeout di visibilità in Amazon SQS
<a name="examples-sqs-visibility-timeout"></a>

Quando un messaggio viene ricevuto in Amazon SQS, rimane in coda fino a quando non viene eliminato per garantire la ricezione. Un messaggio ricevuto, ma non eliminato, sarà disponibile nelle richieste successive dopo un determinato *timeout di visibilità* per evitare che il messaggio venga ricevuto più di una volta prima di poter essere elaborato ed eliminato.

Quando si utilizzano [code standard](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/standard-queues.html), il timeout di visibilità non è una garanzia contro la ricezione di un messaggio due volte. Se utilizzi una coda standard, assicurati che il codice sia in grado di gestire il caso in cui lo stesso messaggio sia stato recapitato più di una volta.

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

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

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

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

## Imposta il timeout di visibilità dei messaggi al momento della ricezione del messaggio
<a name="sqs-visibility-timeout-receipt"></a>

Quando hai ricevuto un messaggio, puoi modificarne il timeout di visibilità inserendo un codice di ricezione [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)che passi alla funzione membro della SQSClient classe. `ChangeMessageVisibility`

 **Include** 

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

 **Codice** 

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

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

## Ulteriori informazioni
<a name="more-info"></a>
+  [Visibility Timeout](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/sqs-visibility-timeout.html) nella Guida per gli sviluppatori di Amazon Simple Queue Service
+  [SetQueueAttributes](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/API_SetQueueAttributes.html)nel riferimento all'API di riferimento di Amazon Simple Queue Service
+  [GetQueueAttributes](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/API_GetQueueAttributes.html)nel riferimento all'API di riferimento di Amazon Simple Queue Service
+  [ReceiveMessage](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/API_ReceiveMessage.html)nel riferimento all'API di riferimento di Amazon Simple Queue Service
+  [ChangeMessageVisibility](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/API_ChangeMessageVisibility.html)nel riferimento all'API di riferimento di Amazon Simple Queue Service
+  [ChangeMessageVisibilityBatch](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/API_ChangeMessageVisibilityBatch.html)nel riferimento all'API di riferimento di Amazon Simple Queue Service

# Utilizzo delle code DLQ in Amazon SQS
<a name="examples-sqs-dead-letter-queues"></a>

Amazon SQS fornisce supporto per le code di *lettere morte*. Una coda di lettere morte è una coda a cui altre code possono indirizzare i messaggi che non possono essere elaborati correttamente. Puoi riservare e isolare questi messaggi nella coda DLQ per determinare perché l'elaborazione non è riuscita.

Per creare una coda di lettere morte, è necessario innanzitutto creare una politica di *redrive e quindi impostare la politica* negli attributi della coda.

**Importante**  
Una coda di lettere morte deve essere dello stesso tipo di coda (FIFO o standard) della coda di origine. Inoltre, deve essere creata utilizzando la stessa coda di Account AWS origine Regione AWS .

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

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

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

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

## Crea una politica di Redrive
<a name="sqs-dead-letter-queue-create-redrive-policy"></a>

Una politica di redrive è specificata in JSON. Per crearla, è possibile utilizzare la classe di utilità JSON fornita con. AWS SDK per C\$1\$1

Ecco una funzione di esempio che crea una politica di redrive fornendole l'ARN della coda delle lettere morte e il numero massimo di volte in cui il messaggio può essere ricevuto e non elaborato prima di essere inviato alla coda di lettere morte.

 **Include** 

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

 **Codice** 

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

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

## Imposta la Redrive Policy nella tua coda di origine
<a name="sqs-dead-letter-queue-set-redrive-policy"></a>

Per completare la configurazione della coda delle lettere morte, chiama la funzione `SetQueueAttributes` member della SQSClient classe con 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)oggetto per il quale hai impostato l'`RedrivePolicy`attributo con la tua politica di redrive JSON.

 **Include** 

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

 **Codice** 

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

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

## Ulteriori informazioni
<a name="more-info"></a>
+  [Utilizzo di Amazon SQS Dead Letter Queues](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/sqs-dead-letter-queues.html) nella Guida per gli sviluppatori di Amazon Simple Queue Service
+  [SetQueueAttributes](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/API_SetQueueAttributes.html)nel riferimento all'API di riferimento di Amazon Simple Queue Service