Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich.

# Geführte Beispiele für Aufrufe AWS-Services mit dem AWS SDK for C\$1\$1
<a name="programming-services"></a>

Wenn Sie mit den AWS Codebeispielen AWS noch nicht vertraut sind, empfehlen wir Ihnen, mit zu beginnen[Erste Schritte mit Codebeispielen](getting-started-code-examples.md).

Quellcode, der zeigt, wie Sie mit AWS Diensten arbeiten, die AWS SDK für C\$1\$1 das verwenden, finden Sie im [Codebeispiele](cpp_code_examples.md) Kapitel dieses Handbuchs oder direkt im [AWS Codebeispiel-Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code) unter GitHub. 

In diesem Abschnitt werden mehrere AWS Dienste ausgewählt und Sie werden durch die Beispiele geführt, in denen sie verwendet werden. Die folgenden Beispiele mit Anleitungen sind eine Teilmenge dessen, was auf Github verfügbar ist.


**Servicebeispiele mit zusätzlichen Erläuterungen (eine vollständige Liste finden Sie im [AWS Codebeispiel-Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code))**  

| Service | Zusammenfassung dessen, was der Service für Ihr Programm bietet | 
| --- | --- | 
| [Amazon CloudWatch](examples-cloudwatch.md) | Erfasst und überwacht Messwerte für die AWS Ressourcen, die Sie verwenden | 
| [Amazon-DynamoDB](examples-dynamodb.md) | Ein NoSQL-Datenbankdienst | 
| [Amazon Elastic Compute Cloud (Amazon EC2)](examples-ec2.md) | Sichere, anpassbare Rechenkapazität | 
| [Amazon Simple Storage Service (Amazon-S3)](examples-s3.md) | Speichern und Abrufen von Daten (Objekte in Buckets) | 
| [Amazon-Simple-Queue-Service (Amazon SQS)](examples-sqs.md) | Message Queuing-Dienst zum Senden, Speichern und Empfangen von Nachrichten zwischen Softwarekomponenten | 

Es gibt auch Beispiele, die zeigen, wie [asynchrone](async-methods.md) Methoden verwendet werden.

Wie Sie dem AWS Dokumentationsteam ein neues Codebeispiel vorschlagen können, finden Sie [unter Richtlinien für Beiträge](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/CONTRIBUTING.md) GitHub zum Erstellen einer neuen Anfrage. Das Team zieht es vor, Codebeispiele zu erstellen, die allgemeine Szenarien zeigen, anstatt einzelne API-Aufrufe.

**Verwenden der Codebeispiele unter Windows**

Wenn Sie die Beispiele unter Windows mit SDK-Version 1.9 erstellen, finden Sie weitere Informationen unter[Behebung von Problemen mit AWS SDK for C\$1\$1 C\$1\$1-Build](troubleshooting-cmake.md).

# CloudWatch Amazon-Beispiele mit dem AWS SDK für C\$1\$1
<a name="examples-cloudwatch"></a>

Amazon CloudWatch (CloudWatch) ist ein Überwachungsdienst für AWS Cloud-Ressourcen und die Anwendungen, auf denen Sie laufen AWS. Sie können die folgenden Beispiele verwenden, um [CloudWatch](https://aws.amazon.com/cloudwatch)mit dem zu programmieren AWS SDK für C\$1\$1.

Amazon CloudWatch überwacht Ihre AWS Ressourcen und die Anwendungen, auf denen Sie laufen, AWS in Echtzeit. Sie können CloudWatch damit Metriken sammeln und verfolgen. Dabei handelt es sich um Variablen, die Sie für Ihre Ressourcen und Anwendungen messen können. CloudWatchAlarme senden Benachrichtigungen oder nehmen auf der Grundlage von von Ihnen festgelegter Regeln automatisch Änderungen an den Ressourcen vor, die Sie überwachen.

Weitere Informationen zu CloudWatch finden Sie im [ CloudWatch Amazon-Benutzerhandbuch](https://docs.aws.amazon.com/AmazonCloudWatch/latest/DeveloperGuide/).

**Anmerkung**  
In diesem Handbuch ist nur der Code enthalten, der zur Demonstration bestimmter Techniken erforderlich ist. Der [vollständige Beispielcode ist jedoch unter verfügbar GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp). Auf können GitHub Sie eine einzelne Quelldatei herunterladen oder das Repository lokal klonen, um alle Beispiele abzurufen, zu erstellen und auszuführen.

**Topics**
+ [Metriken abrufen von CloudWatch](examples-cloudwatch-get-metrics.md)
+ [Veröffentlichen benutzerdefinierter Metrikdaten](examples-cloudwatch-publish-custom-metrics.md)
+ [Mit CloudWatch Alarmen arbeiten](examples-cloudwatch-create-alarms.md)
+ [Verwenden von Alarmaktionen in CloudWatch](examples-cloudwatch-use-alarm-actions.md)
+ [Ereignisse senden an CloudWatch](examples-cloudwatch-send-events.md)

# Metriken abrufen von CloudWatch
<a name="examples-cloudwatch-get-metrics"></a>

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

Bevor Sie beginnen, empfehlen wir Ihnen, [Erste Schritte mit dem zu](getting-started.md) lesen AWS SDK für C\$1\$1. 

Laden Sie den Beispielcode herunter und erstellen Sie die Lösung wie unter beschrieben[Erste Schritte mit Codebeispielen](getting-started-code-examples.md). 

Um die Beispiele ausführen zu können, muss das Benutzerprofil, das Ihr Code für die Anfragen verwendet, über die entsprechenden Berechtigungen verfügen AWS (für den Dienst und die Aktion). Weitere Informationen finden Sie unter [Bereitstellen von AWS Anmeldeinformationen](credentials.md).

## Auflisten von Metriken
<a name="listing-metrics"></a>

Um CloudWatch Metriken aufzulisten, erstellen Sie eine `ListMetrics` Funktion [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)und rufen sie auf. CloudWatchClient Sie können `ListMetricsRequest` zum Filtern der zurückgegebenen Metriken nach Namespace, Metrikname oder Dimensionen verwenden.

**Anmerkung**  
Eine Liste der Metriken und Dimensionen, die von AWS Services veröffentlicht werden, finden Sie in der [Amazon CloudWatch Metrics and Dimensions Reference](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/CW_Support_For_AWS.html) im CloudWatch Amazon-Benutzerhandbuch.

 **Beinhaltet** 

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

 **Code** 

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

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

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

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

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

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

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

Die Metriken werden in a zurückgegeben, [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)indem die zugehörige `GetMetrics` Funktion aufgerufen wird. Eventuell werden die Ergebnisse *seitenweise* zurückgegeben. Um den nächsten Ergebnisstapel abzurufen, rufen Sie das ursprüngliche Anforderungsobjekt mit dem `ListMetricsResult` Rückgabewert der `GetNextToken` Objektfunktion `SetNextToken` auf und übergeben das geänderte Anforderungsobjekt an einen anderen Aufruf von`ListMetrics`.

Siehe [vollständiges Beispiel](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code/cloudwatch/list_metrics.cpp).

## Weitere Informationen
<a name="more-information"></a>
+  [ListMetrics](https://docs.aws.amazon.com/AmazonCloudWatch/latest/APIReference/ListMetrics.html)in der Amazon CloudWatch API-Referenz.

# Veröffentlichen benutzerdefinierter Metrikdaten
<a name="examples-cloudwatch-publish-custom-metrics"></a>

Eine Reihe von AWS Diensten veröffentlichen [ihre eigenen Metriken](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/aws-namespaces.html) in Namespaces, die mit beginnen. `AWS/` Sie können benutzerdefinierte Metrikdaten auch in Ihrem eigenen Namespace veröffentlichen (sofern dieser nicht mit beginnt). `AWS/`

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

Bevor Sie beginnen, empfehlen wir Ihnen, [Erste Schritte mit dem zu](getting-started.md) lesen. AWS SDK für C\$1\$1

Laden Sie den Beispielcode herunter und erstellen Sie die Lösung wie unter beschrieben[Erste Schritte mit Codebeispielen](getting-started-code-examples.md). 

Um die Beispiele ausführen zu können, muss das Benutzerprofil, das Ihr Code für die Anfragen verwendet, über die entsprechenden Berechtigungen verfügen AWS (für den Dienst und die Aktion). Weitere Informationen finden Sie unter [Bereitstellen von AWS Anmeldeinformationen](credentials.md).

## Veröffentlichen benutzerdefinierter Metrikdaten
<a name="publish-custom-metric-data"></a>

Um Ihre eigenen Metrikdaten zu veröffentlichen, rufen Sie die `PutMetricData` Funktion CloudWatchClient's mit einem auf [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). Die `PutMetricDataRequest` muss den benutzerdefinierten Namespace enthalten, der für die Daten verwendet werden soll, und Informationen über den Datenpunkt selbst in einem [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)Objekt.

**Anmerkung**  
Sie können keinen Namespace angeben, der mit beginnt. `AWS/` Namespaces, die mit beginnen, `AWS/` sind für die Verwendung durch Amazon Web Services Services-Produkte reserviert.

 **Beinhaltet** 

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

 **Code** 

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

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

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

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

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

Siehe [vollständiges Beispiel](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code/cloudwatch/put_metric_data.cpp).

## Weitere Informationen
<a name="more-information"></a>
+  [Verwenden von Amazon CloudWatch Metrics](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/working_with_metrics.html) im CloudWatch Amazon-Benutzerhandbuch.
+  [AWS Namespaces](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/aws-namespaces.html) im CloudWatch Amazon-Benutzerhandbuch.
+  [PutMetricData](https://docs.aws.amazon.com/AmazonCloudWatch/latest/APIReference/PutMetricData.html)in der Amazon CloudWatch API-Referenz.

# Mit CloudWatch Alarmen arbeiten
<a name="examples-cloudwatch-create-alarms"></a>

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

Bevor Sie beginnen, empfehlen wir Ihnen, [Erste Schritte mit dem zu](getting-started.md) lesen AWS SDK für C\$1\$1. 

Laden Sie den Beispielcode herunter und erstellen Sie die Lösung wie unter beschrieben[Erste Schritte mit Codebeispielen](getting-started-code-examples.md). 

Um die Beispiele ausführen zu können, muss das Benutzerprofil, das Ihr Code für die Anfragen verwendet, über die entsprechenden Berechtigungen verfügen AWS (für den Dienst und die Aktion). Weitere Informationen finden Sie unter [Bereitstellen von AWS Anmeldeinformationen](credentials.md).

## Einrichten eines Alarms
<a name="create-an-alarm"></a>

Um einen Alarm auf der Grundlage einer CloudWatch Metrik zu erstellen, rufen Sie die `PutMetricAlarm` Funktion CloudWatchClient s mit [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)einer Angabe der Alarmbedingungen auf.

 **Beinhaltet** 

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

 **Code** 

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

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

        request.AddDimensions(dimension);

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

Siehe [vollständiges Beispiel](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code/cloudwatch/put_metric_alarm.cpp).

## Auflisten von Alarmen
<a name="list-alarms"></a>

Um die CloudWatch Alarme aufzulisten, die Sie erstellt haben, rufen Sie die `DescribeAlarms` Funktion CloudWatchClient s mit einer auf [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), mit der Sie Optionen für das Ergebnis festlegen können.

 **Beinhaltet** 

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

 **Code** 

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

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

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

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

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

Die Liste der Alarme kann abgerufen werden, indem Sie `getMetricAlarms` den Befehl aufrufen [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), der von zurückgegeben wird`DescribeAlarms`.

Eventuell werden die Ergebnisse *seitenweise* zurückgegeben. Um den nächsten Ergebnisstapel abzurufen, rufen Sie das ursprüngliche Anforderungsobjekt mit dem `DescribeAlarmsResult` Rückgabewert der `GetNextToken` Objektfunktion `SetNextToken` auf und übergeben das geänderte Anforderungsobjekt an einen anderen Aufruf von`DescribeAlarms`.

**Anmerkung**  
Sie können auch Alarme für eine bestimmte Metrik abrufen, indem Sie die `DescribeAlarmsForMetric` Funktion CloudWatchClient's verwenden. Sie lässt sich ähnlich wie `DescribeAlarms` nutzen.

Siehe [vollständiges Beispiel](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code/cloudwatch/describe_alarms.cpp).

## Löschen von Alarmen
<a name="delete-alarms"></a>

Um CloudWatch Alarme zu löschen, rufen Sie die `DeleteAlarms` Funktion CloudWatchClient s auf, [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)die einen oder mehrere Namen von Alarmen enthält, die Sie löschen möchten.

 **Beinhaltet** 

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

 **Code** 

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

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

Siehe [vollständiges Beispiel](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code/cloudwatch/delete_alarm.cpp).

## Weitere Informationen
<a name="more-information"></a>
+  [ CloudWatch Amazon-Alarme im CloudWatch Amazon-Benutzerhandbuch erstellen](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/AlarmThatSendsEmail.html)
+  [PutMetricAlarm](https://docs.aws.amazon.com/AmazonCloudWatch/latest/APIReference/PutMetricAlarm.html)in der Amazon CloudWatch API-Referenz
+  [DescribeAlarms](https://docs.aws.amazon.com/AmazonCloudWatch/latest/APIReference/DescribeAlarms.html)in der Amazon CloudWatch API-Referenz
+  [DeleteAlarms](https://docs.aws.amazon.com/AmazonCloudWatch/latest/APIReference/DeleteAlarms.html)in der Amazon CloudWatch API-Referenz

# Verwenden von Alarmaktionen in CloudWatch
<a name="examples-cloudwatch-use-alarm-actions"></a>

Mithilfe von CloudWatch Alarmaktionen können Sie Alarme erstellen, die Aktionen wie automatisches Stoppen, Beenden, Neustarten oder Wiederherstellen von Amazon EC2 EC2-Instances ausführen.

[Alarmaktionen können einem Alarm hinzugefügt werden, indem Sie bei der Erstellung eines Alarms [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)die `SetAlarmActions` Funktion verwenden.](examples-cloudwatch-create-alarms.md)

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

Bevor Sie beginnen, empfehlen wir Ihnen, [Erste Schritte mit dem zu](getting-started.md) lesen AWS SDK für C\$1\$1. 

Laden Sie den Beispielcode herunter und erstellen Sie die Lösung wie unter beschrieben[Erste Schritte mit Codebeispielen](getting-started-code-examples.md). 

Um die Beispiele ausführen zu können, muss das Benutzerprofil, das Ihr Code für die Anfragen verwendet, über die entsprechenden Berechtigungen verfügen AWS (für den Dienst und die Aktion). Weitere Informationen finden Sie unter [Bereitstellen von AWS Anmeldeinformationen](credentials.md).

## Aktivieren von Alarmaktionen
<a name="enable-alarm-actions"></a>

Um Alarmaktionen für einen CloudWatch Alarm zu aktivieren, rufen Sie die CloudWatchClient s `EnableAlarmActions` mit einem auf, das einen oder mehrere Namen von Alarmen [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)enthält, deren Aktionen Sie aktivieren möchten.

 **Beinhaltet** 

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

 **Code** 

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

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

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

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

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

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

Siehe [vollständiges Beispiel](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code/cloudwatch/enable_alarm_actions.cpp).

## Deaktivieren von Alarmaktionen
<a name="disable-alarm-actions"></a>

Um Alarmaktionen für einen CloudWatch Alarm zu deaktivieren, rufen Sie die CloudWatchClient s `DisableAlarmActions` mit einem auf, der einen oder mehrere Namen von Alarmen [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)enthält, deren Aktionen Sie deaktivieren möchten.

 **Beinhaltet** 

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

 **Code** 

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

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

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

Siehe [vollständiges Beispiel](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code/cloudwatch/disable_alarm_actions.cpp).

## Weitere Informationen
<a name="more-information"></a>
+  [Alarme zum Stoppen, Beenden, Neustarten oder Wiederherstellen einer Instance im CloudWatch Amazon-Benutzerhandbuch erstellen](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/UsingAlarmActions.html)
+  [PutMetricAlarm](https://docs.aws.amazon.com/AmazonCloudWatch/latest/APIReference/PutMetricAlarm.html)in der Amazon CloudWatch API-Referenz
+  [EnableAlarmActions](https://docs.aws.amazon.com/AmazonCloudWatch/latest/APIReference/EnableAlarmActions.html)in der Amazon CloudWatch API-Referenz
+  [DisableAlarmActions](https://docs.aws.amazon.com/AmazonCloudWatch/latest/APIReference/DisableAlarmActions.html)in der Amazon CloudWatch API-Referenz

# Ereignisse senden an CloudWatch
<a name="examples-cloudwatch-send-events"></a>

CloudWatch Events liefert nahezu in Echtzeit einen Stream von Systemereignissen, die AWS Ressourcenänderungen an Amazon EC2 EC2-Instances, Lambda-Funktionen, Kinesis-Streams, Amazon ECS-Aufgaben, Step Functions Functions-Zustandsmaschinen, Amazon SNS SNS-Themen, Amazon SQS SQS-Warteschlangen oder integrierten Zielen beschreiben. Sie können Ereignisse zuordnen und sie zu einer oder mehreren Zielfunktionen oder Streams umleiten, indem Sie einfache Regeln nutzen.

**Anmerkung**  
[Bei diesen Codefragmenten wird davon ausgegangen, dass Sie das Material [unter Erste Schritte mit dem verstehen AWS SDK für C\$1\$1 und AWS Standardanmeldedaten anhand der Informationen unter](getting-started.md) Anmeldeinformationen bereitstellen konfiguriert haben. AWS](credentials.md)

## Hinzufügen von Ereignissen
<a name="add-events"></a>

Um benutzerdefinierte CloudWatch Ereignisse hinzuzufügen, rufen Sie die `PutEvents` Funktion CloudWatchEventsClient's mit einem [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)Objekt auf, das ein oder mehrere [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)Objekte enthält, die Details zu jedem Ereignis bereitstellen. Sie können mehrere Parameter für den Eintrag angeben, wie z. B. die Quelle und den Typ des Ereignisses, mit dem Ereignis verknüpfte Ressourcen usw.

**Anmerkung**  
Sie können maximal 10 Ereignisse pro Aufruf von `putEvents` angeben.

 **Beinhaltet** 

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

 **Code** 

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

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

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

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

## Hinzufügen von Regeln
<a name="add-rules"></a>

Um eine Regel zu erstellen oder zu aktualisieren, rufen Sie die `PutRule` Funktion CloudWatchEventsClient s [PutRuleRequest](https://docs.aws.amazon.com/sdk-for-cpp/latest/api/aws-cpp-sdk-eventbridge/html/class_aws_1_1_event_bridge_1_1_model_1_1_put_rule_request.html)mit einem Namen der Regel und optionalen Parametern wie dem [Ereignismuster](https://docs.aws.amazon.com/AmazonCloudWatch/latest/events/CloudWatchEventsandEventPatterns.html), der der Regel zuzuordnenden IAM-Rolle und einem [Scheduling-Ausdruck](https://docs.aws.amazon.com/AmazonCloudWatch/latest/events/ScheduledEvents.html) auf, der beschreibt, wie oft die Regel ausgeführt wird.

 **Beinhaltet** 

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

 **Code** 

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

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

## Hinzufügen von Zielen
<a name="add-targets"></a>

Ziele sind die Ressourcen, die beim Auslösen einer Regel aufgerufen werden. Zu den Beispielzielen gehören Amazon EC2 EC2-Instances, Lambda-Funktionen, Kinesis-Streams, Amazon ECS-Aufgaben, Step Functions Functions-Zustandsmaschinen und integrierte Ziele.

Um einer Regel ein Ziel hinzuzufügen, rufen Sie die `PutTargets` 's-Funktion mit einer auf, die CloudWatchEventsClient die zu aktualisierende Regel [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)enthält, und einer Liste von Zielen, die der Regel hinzugefügt werden sollen.

 **Beinhaltet** 

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

 **Code** 

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

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

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

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

Siehe [vollständiges Beispiel](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code/eventbridge/put_targets.cpp).

## Weitere Informationen
<a name="more-information"></a>
+  [Hinzufügen von Ereignissen mit PutEvents](https://docs.aws.amazon.com/AmazonCloudWatch/latest/events/AddEventsPutEvents.html) im Amazon CloudWatch Events-Benutzerhandbuch
+  [Ausdrücke für Regeln planen](https://docs.aws.amazon.com/AmazonCloudWatch/latest/events/ScheduledEvents.html) im Amazon CloudWatch Events-Benutzerhandbuch
+  [Ereignistypen für CloudWatch Ereignisse](https://docs.aws.amazon.com/AmazonCloudWatch/latest/events/EventTypes.html) im Amazon CloudWatch Events-Benutzerhandbuch
+  [Ereignisse und Ereignismuster](https://docs.aws.amazon.com/AmazonCloudWatch/latest/events/CloudWatchEventsandEventPatterns.html) im Amazon CloudWatch Events-Benutzerhandbuch
+  [PutEvents](https://docs.aws.amazon.com/AmazonCloudWatchEvents/latest/APIReference/PutEvents.html)in der Amazon CloudWatch Events API-Referenz
+  [PutTargets](https://docs.aws.amazon.com/AmazonCloudWatchEvents/latest/APIReference/PutTargets.html)in der Amazon CloudWatch Events API-Referenz
+  [PutRule](https://docs.aws.amazon.com/AmazonCloudWatchEvents/latest/APIReference/PutRule.html)in der Amazon CloudWatch Events API-Referenz

# Amazon DynamoDB DynamoDB-Beispiele mit dem AWS SDK für C\$1\$1
<a name="examples-dynamodb"></a>

Amazon DynamoDB ist ein vollständig verwalteter NoSQL-Datenbank-Service, der schnelle und planbare Leistung mit nahtloser Skalierbarkeit bereitstellt. Die folgenden Beispiele zeigen, wie Sie [Amazon DynamoDB](https://aws.amazon.com/dynamodb) mit dem programmieren können. AWS SDK für C\$1\$1

**Anmerkung**  
In diesem Handbuch ist nur der Code enthalten, der zur Veranschaulichung bestimmter Techniken erforderlich ist. Der [vollständige Beispielcode ist jedoch unter verfügbar](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp). GitHub Auf können GitHub Sie eine einzelne Quelldatei herunterladen oder das Repository lokal klonen, um alle Beispiele abzurufen, zu erstellen und auszuführen.

**Topics**
+ [Arbeiten mit Tabellen in DynamoDB](examples-dynamodb-tables.md)
+ [Arbeiten mit Elementen in DynamoDB](examples-dynamodb-items.md)

# Arbeiten mit Tabellen in DynamoDB
<a name="examples-dynamodb-tables"></a>

Tabellen sind die Container für alle Elemente in einer DynamoDB-Datenbank. Bevor Sie Daten aus DynamoDB hinzufügen oder daraus entfernen können, müssen Sie eine Tabelle erstellen.

Für jede Tabelle definieren Sie:
+ Ein *Tabellenname*, der für Ihr AWS-Konto und eindeutig ist. AWS-Region
+ Ein *Primärschlüssel*, für den jeder Wert eindeutig sein muss. Keine zwei Elemente in Ihrer Tabelle dürfen denselben Primärschlüsselwert haben.

  Ein Primärschlüssel kann *einfach* sein, also aus einem Schlüssel mit einer einzigen Partition (HASH) bestehen, oder *zusammengesetzt*, also aus einer Partition und einem Sortierschlüssel (RANGE).

  Jedem Schlüsselwert ist ein *Datentyp* zugeordnet, der nach der [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)Klasse aufgezählt wird. Der Schlüsselwert kann binär (B), numerisch (n) oder eine Zeichenfolge (S) sein. Weitere Informationen finden Sie unter [Benennungsregeln und Datentypen](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/HowItWorks.NamingRulesDataTypes.html) im Amazon DynamoDB Developer Guide.
+  *Bereitgestellte Durchsatzwerte*, die die Anzahl der reservierten read/write Kapazitätseinheiten für die Tabelle definieren.
**Anmerkung**  
 [Amazon DynamoDB-Preise](https://aws.amazon.com/dynamodb/pricing/) basieren auf dem bereitgestellten Durchsatz von Tabellen. Reservieren Sie also nur so viel Kapazität, wie Sie Ihrer Meinung nach je für die Tabelle brauchen werden.  
Der bereitgestellte Durchsatz für eine Tabelle kann jederzeit geändert werden. So können Sie die Kapazität anpassen, wenn sich Ihre Anforderungen ändern.

## Erstellen einer Tabelle
<a name="dynamodb-create-table"></a>

Verwenden Sie die [`CreateTable`DynamoDB-Clientmethode](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), um eine neue DynamoDB-Tabelle zu erstellen. Sie müssen Tabellenattribute und ein Tabellenschema erstellen. Beide Komponenten fließen in den Primärschlüssel der Tabelle ein. Sie müssen auch die anfänglichen bereitgestellten Durchsatzwerte und einen Tabellennamen angeben. `CreateTable`ist ein asynchroner Vorgang. `GetTableStatus`gibt CREATING zurück, bis die Tabelle AKTIV und einsatzbereit ist.

### Erstellen einer Tabelle mit einem einfachen Primärschlüssel
<a name="dynamodb-create-table-simple"></a>

Dieser Code erstellt eine Tabelle mit einem einfachen Primärschlüssel („Name“).

 **Beinhaltet** 

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

 **Code** 

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

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

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

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

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

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

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

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

Siehe [vollständiges Beispiel](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code/dynamodb/create_table.cpp).

### Erstellen einer Tabelle mit einem zusammengesetzten Primärschlüssel
<a name="dynamodb-create-table-composite"></a>

Füge ein weiteres hinzu [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)und [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)zu [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).

 **Beinhaltet** 

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

 **Code** 

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

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

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

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

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

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

    request.SetTableName(tableName);

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

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

Das [vollständige Beispiel](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code/dynamodb/create_table_composite_key.cpp) finden Sie unter GitHub.

## Auflisten von Tabellen
<a name="dynamodb-list-tables"></a>

Sie können die Tabellen in einer bestimmten Region auflisten, indem Sie die [`ListTables`DynamoDB-Clientmethode](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) aufrufen.

 **Beinhaltet** 

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

 **Code** 

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

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

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

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

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

    return true;
}
```

Standardmäßig werden bis zu 100 Tabellen pro Aufruf zurückgegeben. Wird für das zurückgegebene [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)Objekt verwendet`GetExclusiveStartTableName`, um die letzte Tabelle abzurufen, die ausgewertet wurde. Mit diesem Wert können Sie die Auflistung nach dem zuletzt zurückgegebenen Wert der vorherigen Auflistung beginnen.

Siehe [vollständiges Beispiel](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code/dynamodb/list_tables.cpp).

## Informationen zu einer Tabelle abrufen
<a name="dynamodb-describe-table"></a>

Sie können mehr über eine Tabelle erfahren, indem Sie die [`DescribeTable`DynamoDB-Clientmethode](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) aufrufen.

 **Beinhaltet** 

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

 **Code** 

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

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

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

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

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

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

    return outcome.IsSuccess();
}
```

Das [vollständige Beispiel](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code/dynamodb/describe_table.cpp) finden Sie unter GitHub.

## Ändern Sie eine Tabelle
<a name="dynamodb-update-table"></a>

Sie können die bereitgestellten Durchsatzwerte Ihrer Tabelle jederzeit ändern, indem Sie die [DynamoDB-Clientmethode](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) aufrufen. `UpdateTable`

 **Beinhaltet** 

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

 **Code** 

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

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

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

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

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

Siehe [vollständiges Beispiel](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code/dynamodb/update_table.cpp).

## Löschen einer Tabelle
<a name="dynamodb-delete-table"></a>

Rufen Sie die [`DeleteTable`DynamoDB-Clientmethode](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) auf und übergeben Sie ihr den Namen der Tabelle.

 **Beinhaltet** 

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

 **Code** 

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

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

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

    return result.IsSuccess();
}
```

Das [vollständige Beispiel](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code/dynamodb/delete_table.cpp) finden Sie unter GitHub.

## Weitere Infos
<a name="more-info"></a>
+  [Richtlinien für die Arbeit mit Tabellen](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/GuidelinesForTables.html) im Amazon DynamoDB DynamoDB-Entwicklerhandbuch
+  [Arbeiten mit Tabellen in DynamoDB im](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/WorkingWithTables.html) Amazon DynamoDB Developer Guide

# Arbeiten mit Elementen in DynamoDB
<a name="examples-dynamodb-items"></a>

*In DynamoDB ist ein Element eine Sammlung von *Attributen*, von denen jedes einen *Namen und einen Wert* hat.* Ein Attributwert kann eine Skalarfunktion, eine Gruppe oder ein Dokumenttyp sein. Weitere Informationen finden Sie unter [Benennungsregeln und Datentypen](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/HowItWorks.NamingRulesDataTypes.html) im Amazon DynamoDB Developer Guide.

## Rufen Sie ein Element aus einer Tabelle ab
<a name="dynamodb-get-item"></a>

Rufen Sie die [`GetItem`DynamoDB-Clientmethode](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) auf. Übergeben Sie ihr ein [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)Objekt mit dem Tabellennamen und dem Primärschlüsselwert des gewünschten Elements. Es gibt ein [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)Objekt zurück.

Sie können die `GetItem()` Methode des zurückgegebenen `GetItemResult` Objekts verwenden, um eine Anzahl `Aws::Map` von Schlüssel `Aws::String` - und [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)Wertepaaren abzurufen, die dem Element zugeordnet sind.

 **Beinhaltet** 

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

 **Code** 

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

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

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

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

    return outcome.IsSuccess();
}
```

Das [vollständige Beispiel](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code/dynamodb/get_item.cpp) finden Sie unter GitHub.

## Fügen Sie ein Element zu einer Tabelle hinzu
<a name="dynamodb-add-item"></a>

Erstellen Sie Schlüssel `Aws::String` - und [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)Wertepaare, die jedes Element repräsentieren. Diese müssen Werte für die Primärschlüsselfelder der Tabelle enthalten. Wenn das Element mit dem Primärschlüssel bereits vorhanden ist, werden dessen Felder durch die Anforderung *aktualisiert*. Fügen Sie sie [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)mithilfe der `AddItem` Methode hinzu.

 **Beinhaltet** 

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

 **Code** 

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

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

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

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

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

Das [vollständige Beispiel](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code/dynamodb/put_item.cpp) finden Sie unter GitHub.

## Aktualisieren eines vorhandenen Elements in einer Tabelle
<a name="dynamodb-update-item"></a>

Sie können ein Attribut für ein Element aktualisieren, das bereits in einer Tabelle vorhanden DBClient ist, indem Sie die `UpdateItem` Dynamo-Methode verwenden und dabei einen Tabellennamen, einen Primärschlüsselwert und zu aktualisierende Felder sowie den entsprechenden Wert angeben.

 **Importe** 

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

 **Code** 

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

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

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

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

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

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

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

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

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

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

Siehe [vollständiges Beispiel](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code/dynamodb/update_item.cpp).

## Weitere Infos
<a name="more-info"></a>
+  [Richtlinien für die Arbeit mit Elementen](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/GuidelinesForItems.html) im Amazon DynamoDB DynamoDB-Entwicklerhandbuch
+  [Arbeiten mit Elementen in DynamoDB im](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/WorkingWithItems.html) Amazon DynamoDB Developer Guide

# Amazon EC2 EC2-Beispiele mit dem AWS SDK für C\$1\$1
<a name="examples-ec2"></a>

Amazon Elastic Compute Cloud (Amazon EC2) ist ein Webservice, der skalierbare Rechenkapazität — buchstäblich Server in den Rechenzentren von Amazon — bereitstellt, die Sie zum Erstellen und Hosten Ihrer Softwaresysteme verwenden. Sie können die folgenden Beispiele verwenden, um [Amazon EC2](https://aws.amazon.com/ec2) mit dem AWS SDK für C\$1\$1 zu programmieren.

**Anmerkung**  
In diesem Handbuch ist nur der Code enthalten, der zur Demonstration bestimmter Techniken erforderlich ist. Der [vollständige Beispielcode ist jedoch unter GitHub verfügbar](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp). Auf können GitHub Sie eine einzelne Quelldatei herunterladen oder das Repository lokal klonen, um alle Beispiele abzurufen, zu erstellen und auszuführen.

**Topics**
+ [Verwalten von Amazon EC2 Instances](examples-ec2-instances.md)
+ [Verwenden von Elastic IP-Adressen in Amazon EC2](examples-ec2-elastic-ip.md)
+ [Verwenden von Regionen und Availability Zones für Amazon EC2](examples-ec2-regions-zones.md)
+ [Arbeiten mit Amazon EC2-Schlüsselpaaren](examples-ec2-key-pairs.md)
+ [Arbeiten mit Sicherheitsgruppen in Amazon EC2](examples-ec2-security-groups.md)

# Verwalten von Amazon EC2 Instances
<a name="examples-ec2-instances"></a>

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

Bevor Sie beginnen, empfehlen wir Ihnen, [Erste Schritte mit dem AWS SDK für C\$1\$1 zu](getting-started.md) lesen. 

Laden Sie den Beispielcode herunter und erstellen Sie die Lösung wie unter beschrieben[Erste Schritte mit Codebeispielen](getting-started-code-examples.md). 

Um die Beispiele ausführen zu können, muss das Benutzerprofil, das Ihr Code für die Anfragen verwendet, über die entsprechenden Berechtigungen verfügen AWS (für den Dienst und die Aktion). Weitere Informationen finden Sie unter [Bereitstellen von AWS Anmeldeinformationen](credentials.md).

## Erstellen einer -Instance
<a name="create-an-instance"></a>

Erstellen Sie eine neue Amazon EC2 EC2-Instance, indem Sie die `RunInstances` Funktion des EC2 Clients aufrufen und ihr ein zu [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)verwendendes [Amazon Machine Image (AMI)](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/AMIs.html) und einen [Instance-Typ](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/instance-types.html) zur Verfügung stellen.

 **Beinhaltet** 

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

 **Code** 

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

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

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

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

Siehe [vollständiges Beispiel](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code/ec2/run_instances.cpp).

## Starten Sie eine Instanz
<a name="start-an-instance"></a>

Um eine Amazon EC2 EC2-Instance zu starten, rufen Sie die `StartInstances` Funktion des EC2 Clients auf und geben ihr eine, die die ID der zu startenden Instance [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)enthält.

 **Beinhaltet** 

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

 **Code** 

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

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

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

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

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

Siehe [vollständiges Beispiel](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code/ec2/start_stop_instance.cpp).

## Stoppen Sie eine Instanz
<a name="stop-an-instance"></a>

Um eine Amazon EC2 EC2-Instance zu stoppen, rufen Sie die `StopInstances` Funktion des EC2 Clients auf und geben ihr eine, die die ID der zu stoppenden Instance [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)enthält.

 **Beinhaltet** 

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

 **Code** 

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

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

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

Siehe [vollständiges Beispiel](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code/ec2/start_stop_instance.cpp).

## Neustarten einer Instance
<a name="reboot-an-instance"></a>

Um eine Amazon EC2 EC2-Instance neu zu starten, rufen Sie die `RebootInstances` Funktion des EC2 Clients auf und geben ihr eine, die die ID der neu zu startenden Instance [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)enthält.

 **Beinhaltet** 

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

 **Code** 

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

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

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

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

Siehe [vollständiges Beispiel](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code/ec2/reboot_instance.cpp).

## Instances beschreiben
<a name="describe-instances"></a>

Um Ihre Instanzen aufzulisten, erstellen Sie eine EC2 `DescribeInstances` Client-Funktion [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)und rufen Sie sie auf. Es wird ein [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)Objekt zurückgegeben, mit dem Sie die Amazon EC2 EC2-Instances für Ihr AWS-Konto und AWS-Region auflisten können.

Instances werden nach *Reservierung* gruppiert. Jede Reservierung entspricht dem Aufruf von `StartInstances`, durch den die Instance gestartet wurde. Um Ihre Instances aufzulisten, müssen Sie zuerst die `GetReservations` Funktion der `DescribeInstancesResponse` Klasse aufrufen und dann jedes zurückgegebene `getInstances` Reservierungsobjekt aufrufen.

 **Beinhaltet** 

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

 **Code** 

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

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

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

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

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

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

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

Die Ergebnisse werden seitenweise angezeigt. Weitere Ergebnisse erhalten Sie, indem Sie den von der Funktion des Ergebnisobjekts zurückgegebenen Wert an die `GetNextToken` Funktion Ihres ursprünglichen Anforderungsobjekts `SetNextToken` übergeben und dann dasselbe Anforderungsobjekt beim nächsten Aufruf von verwenden. `DescribeInstances`

Siehe [vollständiges Beispiel](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code/ec2/describe_instances.cpp).

## Aktivieren Sie die Instanzüberwachung
<a name="enable-instance-monitoring"></a>

Sie können verschiedene Aspekte Ihrer Amazon EC2 EC2-Instances überwachen, z. B. die CPU- und Netzwerkauslastung, den verfügbaren Arbeitsspeicher und den verbleibenden Festplattenspeicher. Weitere Informationen zur Instance-Überwachung finden Sie unter [Monitoring Amazon EC2](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/monitoring_ec2.html) im Amazon EC2 EC2-Benutzerhandbuch.

Um mit der Überwachung einer Instance zu beginnen, müssen Sie eine [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)mit der ID der zu überwachenden Instance erstellen und diese an die EC2 Client-Funktion übergeben. `MonitorInstances`

 **Beinhaltet** 

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

 **Code** 

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

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

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

Siehe [vollständiges Beispiel](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code/ec2/monitor_instance.cpp).

## Deaktivieren Sie die Instanzüberwachung
<a name="disable-instance-monitoring"></a>

Um die Überwachung einer Instanz zu beenden, erstellen Sie eine [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)mit der ID der Instanz, deren Überwachung beendet werden soll, und übergeben Sie sie an die `UnmonitorInstances` Funktion des EC2 Clients.

 **Beinhaltet** 

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

 **Code** 

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

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

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

Siehe [vollständiges Beispiel](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code/ec2/monitor_instance.cpp).

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

# Verwenden von Elastic IP-Adressen in Amazon EC2
<a name="examples-ec2-elastic-ip"></a>

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

Bevor Sie beginnen, empfehlen wir Ihnen, [Getting started using the AWS SDK für C\$1\$1 zu](getting-started.md) lesen. 

Laden Sie den Beispielcode herunter und erstellen Sie die Lösung wie unter beschrieben[Erste Schritte mit Codebeispielen](getting-started-code-examples.md). 

Um die Beispiele ausführen zu können, muss das Benutzerprofil, das Ihr Code für die Anfragen verwendet, über die entsprechenden Berechtigungen verfügen AWS (für den Dienst und die Aktion). Weitere Informationen finden Sie unter [Bereitstellen von AWS Anmeldeinformationen](credentials.md).

## Weisen Sie eine Elastic IP-Adresse zu
<a name="allocate-an-elastic-ip-address"></a>

Um eine Elastic IP-Adresse zu verwenden, verknüpfen Sie sie zuerst mit Ihrem Konto und anschließend mit Ihrer Instance oder Netzwerkschnittstelle.

Um eine Elastic IP-Adresse zuzuweisen, rufen Sie die `AllocateAddress` Funktion des EC2 Clients mit einem [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)Objekt auf, das den Netzwerktyp (klassisch EC2 oder VPC) enthält. 

**Warnung**  
EC2-Classic wird am 15. August 2022 eingestellt. Wir empfehlen Ihnen die Migration von EC2-Classic zu einer VPC. Weitere Informationen finden Sie unter **Migration von EC2-Classic zu einer VPC** im [Amazon EC2 EC2-Benutzerhandbuch für Linux-Instances oder im [Amazon EC2 EC2-Benutzerhandbuch](https://docs.aws.amazon.com/AWSEC2/latest/WindowsGuide/vpc-migrate.html) für](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/vpc-migrate.html) Windows-Instances. Lesen Sie außerdem den Blogbeitrag [EC2-Classic Networking is Retiring – Here's How to Prepare](https://aws.amazon.com/blogs/aws/ec2-classic-is-retiring-heres-how-to-prepare/) (EC2-Classic Networking wird außer Betrieb genommen – so bereiten Sie sich vor).

Die [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)Klasse im Antwortobjekt enthält eine Zuweisungs-ID, mit der Sie die Adresse einer Instance zuordnen können, indem Sie die Zuweisungs-ID und die Instance-ID in a [AssociateAddressRequest](https://docs.aws.amazon.com/sdk-for-cpp/latest/api/aws-cpp-sdk-ec2/html/class_aws_1_1_e_c2_1_1_model_1_1_associate_address_request.html)an die Client-Funktion übergeben. EC2 `AssociateAddress`

 **Beinhaltet** 

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

 **Code** 

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

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

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


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

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

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

Siehe [vollständiges Beispiel](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code/ec2/allocate_address.cpp).

## Beschreiben von Elastic IP-Adressen
<a name="describe-elastic-ip-addresses"></a>

Rufen Sie die EC2 `DescribeAddresses` Client-Funktion auf, um die Elastic IP-Adressen aufzulisten, die Ihrem Konto zugewiesen sind. Sie gibt ein Ergebnisobjekt zurück, das ein enthält, mit [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)dem Sie eine Liste von [Address-Objekten](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) abrufen können, die die Elastic IP-Adressen in Ihrem Konto repräsentieren.

 **Beinhaltet** 

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

 **Code** 

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

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

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

Siehe [vollständiges Beispiel](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code/ec2/describe_addresses.cpp).

## Freigeben einer Elastic IP-Adresse
<a name="release-an-elastic-ip-address"></a>

Um eine Elastic IP-Adresse freizugeben, rufen Sie die `ReleaseAddress` Funktion des EC2 Clients auf und übergeben ihr eine, die die Zuweisungs-ID der Elastic IP-Adresse [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)enthält, die Sie freigeben möchten.

 **Beinhaltet** 

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

 **Code** 

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

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

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

Nachdem Sie eine Elastic IP-Adresse veröffentlicht haben, wird sie für den AWS IP-Adresspool freigegeben und steht Ihnen danach möglicherweise nicht mehr zur Verfügung. Achten Sie darauf, die DNS-Datensätze sowie alle Server und Geräte zu aktualisieren, die mit der Adresse kommunizieren. Wenn Sie versuchen, eine Elastic IP-Adresse freizugeben, die Sie bereits veröffentlicht haben, erhalten Sie eine *AuthFailure*Fehlermeldung, wenn die Adresse bereits einem anderen AWS Konto zugewiesen ist.

Wenn Sie eine *Standard-VPC verwenden, trennt* die Freigabe einer Elastic IP-Adresse diese automatisch von allen Instances, mit denen sie verknüpft ist. Verwenden Sie die Funktion des EC2 Clients, um die Zuordnung einer Elastic IP-Adresse zu trennen, ohne sie freizugeben. `DisassociateAddress`

Wenn Sie einen Nicht-Standard-VPC verwenden, *müssen* Sie die Verknüpfung der Elastic IP-Adresse mit `DisassociateAddress` aufheben, bevor Sie versuchen, sie freizugeben. Andernfalls gibt Amazon EC2 einen Fehler zurück (*UngültigIPAddress). InUse*).

Siehe [vollständiges Beispiel](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code/ec2/release_address.cpp).

## Weitere Informationen
<a name="more-information"></a>
+  [Elastic IP-Adressen](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/elastic-ip-addresses-eip.html) im Amazon EC2 EC2-Benutzerhandbuch
+  [AllocateAddress](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_AllocateAddress.html)in der Amazon EC2 API-Referenz
+  [DescribeAddresses](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_DescribeAddresses.html)in der Amazon EC2 API-Referenz
+  [ReleaseAddress](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_ReleaseAddress.html)in der Amazon EC2 API-Referenz

# Verwenden von Regionen und Availability Zones für Amazon EC2
<a name="examples-ec2-regions-zones"></a>

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

Bevor Sie beginnen, empfehlen wir Ihnen, [Erste Schritte mit dem AWS SDK für C\$1\$1 zu](getting-started.md) lesen. 

Laden Sie den Beispielcode herunter und erstellen Sie die Lösung wie unter beschrieben[Erste Schritte mit Codebeispielen](getting-started-code-examples.md). 

Um die Beispiele ausführen zu können, muss das Benutzerprofil, das Ihr Code für die Anfragen verwendet, über die entsprechenden Berechtigungen verfügen AWS (für den Dienst und die Aktion). Weitere Informationen finden Sie unter [Bereitstellen von AWS Anmeldeinformationen](credentials.md).

## Beschreiben von Regionen
<a name="describe-regions"></a>

Um die AWS-Regionen verfügbaren Optionen aufzulisten AWS-Konto, rufen Sie die EC2 `DescribeRegions` Client-Funktion mit einem auf [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).

[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)Im Ergebnis erhalten Sie ein Objekt. Rufen Sie seine `GetRegions` Funktion auf, um eine Liste von [Region-Objekten](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) zu erhalten, die jede Region repräsentieren.

 **Beinhaltet** 

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

 **Code** 

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

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

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

Siehe [vollständiges Beispiel](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code/ec2/describe_regions_and_zones.cpp).

## Beschreiben von Availability Zones
<a name="describe-availability-zones"></a>

Um alle Verfügbarkeitszonen aufzulisten, die für Ihr Konto verfügbar sind, rufen Sie die EC2 `DescribeAvailabilityZones` Client-Funktion mit einem auf [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).

[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)Im Ergebnis erhalten Sie ein Objekt. Rufen Sie seine `GetAvailabilityZones` Funktion auf, um eine Liste von [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)Objekten abzurufen, die jede Verfügbarkeitszone repräsentieren.

 **Beinhaltet** 

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

 **Code** 

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

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

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

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

    }
```

Siehe [vollständiges Beispiel](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code/ec2/describe_regions_and_zones.cpp).

## Weitere Informationen
<a name="more-information"></a>
+  [Regionen und Availability Zones](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/using-regions-availability-zones.html) im Amazon EC2 EC2-Benutzerhandbuch
+  [DescribeRegions](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_DescribeRegions.html)in der Amazon EC2 API-Referenz
+  [DescribeAvailabilityZones](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_DescribeAvailabilityZones.html)in der Amazon EC2 API-Referenz

# Arbeiten mit Amazon EC2-Schlüsselpaaren
<a name="examples-ec2-key-pairs"></a>

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

Bevor Sie beginnen, empfehlen wir Ihnen, [Erste Schritte mit dem AWS SDK für C\$1\$1 zu](getting-started.md) lesen. 

Laden Sie den Beispielcode herunter und erstellen Sie die Lösung wie unter beschrieben[Erste Schritte mit Codebeispielen](getting-started-code-examples.md). 

Um die Beispiele ausführen zu können, muss das Benutzerprofil, das Ihr Code für die Anfragen verwendet, über die entsprechenden Berechtigungen verfügen AWS (für den Dienst und die Aktion). Weitere Informationen finden Sie unter [Bereitstellen von AWS Anmeldeinformationen](credentials.md).

## Erstellen eines Schlüsselpaares
<a name="create-a-key-pair"></a>

Um ein key pair zu erstellen, rufen Sie die `CreateKeyPair` Funktion des EC2 Clients mit einer auf [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), die den Namen des Schlüssels enthält.

 **Beinhaltet** 

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

 **Code** 

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

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

    }
```

Siehe [vollständiges Beispiel](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code/ec2/create_key_pair.cpp).

## Schlüsselpaare beschreiben
<a name="describe-key-pairs"></a>

Um Ihre Schlüsselpaare aufzulisten oder Informationen über sie zu erhalten, rufen Sie die EC2 `DescribeKeyPairs` Client-Funktion mit einem auf [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).

Sie erhalten eine [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), mit der Sie auf die Liste der Schlüsselpaare zugreifen können, indem Sie ihre `GetKeyPairs` Funktion aufrufen, die eine Liste von [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)Objekten zurückgibt.

 **Beinhaltet** 

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

 **Code** 

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

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

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

Siehe [vollständiges Beispiel](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code/ec2/describe_key_pairs.cpp).

## Löschen eines Schlüsselpaars
<a name="delete-a-key-pair"></a>

Um ein key pair zu löschen, rufen Sie die `DeleteKeyPair` Funktion des EC2 Clients auf und übergeben Sie ihr eine [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), die den Namen des zu löschenden key pair enthält.

 **Beinhaltet** 

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

 **Code** 

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

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

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

Siehe [vollständiges Beispiel](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code/ec2/delete_key_pair.cpp).

## Weitere Informationen
<a name="more-information"></a>
+  [Amazon EC2 EC2-Schlüsselpaare](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-key-pairs.html) im Amazon EC2 EC2-Benutzerhandbuch
+  [CreateKeyPair](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_CreateKeyPair.html)in der Amazon EC2 API-Referenz
+  [DescribeKeyPairs](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_DescribeKeyPairs.html)in der Amazon EC2 API-Referenz
+  [DeleteKeyPair](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_DeleteKeyPair.html)in der Amazon EC2 API-Referenz

# Arbeiten mit Sicherheitsgruppen in Amazon EC2
<a name="examples-ec2-security-groups"></a>

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

Bevor Sie beginnen, empfehlen wir Ihnen, [Erste Schritte mit dem AWS SDK für C\$1\$1 zu](getting-started.md) lesen. 

Laden Sie den Beispielcode herunter und erstellen Sie die Lösung wie unter beschrieben[Erste Schritte mit Codebeispielen](getting-started-code-examples.md). 

Um die Beispiele ausführen zu können, muss das Benutzerprofil, das Ihr Code für die Anfragen verwendet, über die entsprechenden Berechtigungen verfügen AWS (für den Dienst und die Aktion). Weitere Informationen finden Sie unter [Bereitstellen von AWS Anmeldeinformationen](credentials.md).

## Erstellen einer Sicherheitsgruppe
<a name="create-a-security-group"></a>

Um eine Sicherheitsgruppe zu erstellen, rufen Sie die EC2 `CreateSecurityGroup` Client-Funktion mit einer auf [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), die den Namen des Schlüssels enthält.

 **Beinhaltet** 

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

 **Code** 

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

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

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

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

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

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

Siehe [vollständiges Beispiel](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code/ec2/create_security_group.cpp).

## Konfigurieren einer Sicherheitsgruppe
<a name="configure-a-security-group"></a>

Eine Sicherheitsgruppe kann sowohl den eingehenden (eingehenden) als auch den ausgehenden (ausgehenden) Datenverkehr zu Ihren Amazon EC2 EC2-Instances kontrollieren.

Um Ihrer Sicherheitsgruppe Eingangsregeln hinzuzufügen, verwenden Sie die EC2 `AuthorizeSecurityGroupIngress` Client-Funktion und geben Sie den Namen der Sicherheitsgruppe und die Zugriffsregeln ([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)) an, die Sie ihr innerhalb eines Objekts zuweisen möchten. [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) Im folgenden Beispiel wird gezeigt, wie Sie einer Sicherheitsgruppe IP-Berechtigungen hinzufügen.

 **Beinhaltet** 

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

 **Code** 

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

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

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

    authorize_request.AddIpPermissions(permission1);

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

    authorize_request.AddIpPermissions(permission2);
```

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

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

Um der Sicherheitsgruppe eine Ausgangsregel hinzuzufügen, geben Sie ähnliche Daten in einer `AuthorizeSecurityGroupEgress` Funktion [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)für den EC2 Client an.

Siehe [vollständiges Beispiel](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code/ec2/create_security_group.cpp).

## Beschreiben Sie Sicherheitsgruppen
<a name="describe-security-groups"></a>

Um Ihre Sicherheitsgruppen zu beschreiben oder Informationen über sie zu erhalten, rufen Sie die EC2 `DescribeSecurityGroups` Client-Funktion mit einem [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)auf.

[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)Im Ergebnis erhalten Sie ein Objekt, mit dem Sie auf die Liste der Sicherheitsgruppen zugreifen können, indem Sie dessen `GetSecurityGroups` Funktion aufrufen, die eine Liste von [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)Objekten zurückgibt.

 **Beinhaltet** 

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

 **Code** 

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

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

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

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

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

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

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

Siehe [vollständiges Beispiel](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code/ec2/describe_security_groups.cpp).

## Löschen einer Sicherheitsgruppe
<a name="delete-a-security-group"></a>

Um eine Sicherheitsgruppe zu löschen, rufen Sie die EC2 `DeleteSecurityGroup` Client-Funktion auf und übergeben ihr eine [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), die die ID der zu löschenden Sicherheitsgruppe enthält.

 **Beinhaltet** 

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

 **Code** 

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

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

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

Siehe [vollständiges Beispiel](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code/ec2/delete_security_group.cpp).

## Weitere Informationen
<a name="more-information"></a>
+  [Amazon EC2-Sicherheitsgruppen](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-key-pairs.html) im Amazon EC2 EC2-Benutzerhandbuch
+  [Autorisieren von eingehendem Traffic für Ihre Linux-Instances](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/authorizing-access-to-an-instance.html) im Amazon EC2 EC2-Benutzerhandbuch
+  [CreateSecurityGroup](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_CreateSecurityGroup.html)in der Amazon EC2 API-Referenz
+  [DescribeSecurityGroups](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_DescribeSecurityGroups.html)in der Amazon EC2 API-Referenz
+  [DeleteSecurityGroup](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_DeleteSecurityGroup.html)in der Amazon EC2 API-Referenz
+  [AuthorizeSecurityGroupIngress](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_AuthorizeSecurityGroupIngress.html)in der Amazon EC2 API-Referenz

# Amazon S3 S3-Codebeispiele mit dem AWS SDK für C\$1\$1
<a name="examples-s3"></a>

[Amazon S3](https://aws.amazon.com/s3) ist ein Objektspeicher, der zum Speichern und Abrufen beliebiger Datenmengen von überall entwickelt wurde. Es gibt mehrere Klassen, die von der Schnittstelle AWS SDK für C\$1\$1 zu Amazon S3 bereitgestellt werden. 

**Anmerkung**  
In diesem Handbuch ist nur der Code enthalten, der zur Demonstration bestimmter Techniken erforderlich ist. Der [vollständige Beispielcode ist jedoch unter verfügbar GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp). Auf können GitHub Sie eine einzelne Quelldatei herunterladen oder das Repository lokal klonen, um alle Beispiele abzurufen, zu erstellen und auszuführen.
+ [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)-Klasse 

  Die `S3Client` Bibliothek ist eine Amazon S3 S3-Schnittstelle mit vollem Funktionsumfang.

  Das `list_buckets_disabling_dns_cache.cpp` Beispiel in diesem Set ist speziell für die Arbeit mit eingeschaltetem CURL konzipiert Linux/Mac (kann jedoch so geändert werden, dass es unter Windows funktioniert). Wenn Sie Windows verwenden, löschen Sie die Datei, `list_buckets_disabling_dns_cache.cpp` bevor Sie das Projekt erstellen, da sie auf dem CURL HttpClient von Linux basiert.

  Der Beispielcode, der das verwendet, `S3Client` befindet sich im [`s3`Ordner](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code/s3) auf Github. Eine vollständige Liste der Funktionen, die in diesem Beispielsatz demonstriert wurden, finden Sie in der [Readme-Datei](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code/s3/README.md) auf Github.

  Teile des `s3` Beispielsatzes werden in diesem Handbuch ausführlicher behandelt:
  + [Buckets erstellen, auflisten und löschen](examples-s3-buckets.md)
  + [Operationen für Objekte](examples-s3-objects.md)— Datenobjekte hochladen und herunterladen
  + [Amazon S3 S3-Zugriffsberechtigungen verwalten](examples-s3-access-permissions.md)
  + [Verwaltung des Zugriffs auf Amazon S3 S3-Buckets mithilfe von Bucket-Richtlinien](examples-s3-bucket-policies.md)
  + [Konfiguration eines Amazon S3 S3-Buckets als Website](examples-s3-website-configuration.md)
+ [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)-Klasse 

  Das `S3CrtClient` wurde in Version 1.9 des SDK hinzugefügt. `S3CrtClient`bietet einen hohen Durchsatz für Amazon S3 S3-GET- (Download) - und PUT- (Upload) -Operationen. Das `S3CrtClient` ist auf der Grundlage der AWS Common Runtime (CRT) -Bibliotheken implementiert. 

  Der Beispielcode, der das verwendet, `S3CrtClient` befindet sich im [`s3-crt`Ordner](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code/s3-crt) auf Github. Eine vollständige Liste der Funktionen, die in diesem Beispielsatz demonstriert wurden, finden Sie in der [Readme-Datei](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code/s3-crt/README.md) auf Github.
  + [`S3CrtClient`Für Amazon S3 S3-Operationen verwenden](examples-s3-crt.md)
+ [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)-Klasse 

  `TransferManager`ist ein vollständig verwalteter Service, der die Übertragung von Dateien über das File Transfer Protocol (FTP), File Transfer Protocol over SSL (FTPS) oder Secure Shell (SSH) File Transfer Protocol (SFTP) direkt in und aus Amazon S3 ermöglicht.

  Der Beispielcode, der das verwendet, `TransferManager` befindet sich im [`transfer-manager`Ordner](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code/transfer-manager) auf Github. Eine vollständige Liste der Funktionen, die in diesem Beispielsatz demonstriert wurden, finden Sie in der [Readme-Datei](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code/transfer-manager/README.md) auf Github.
  + [TransferManager Für Amazon S3 S3-Operationen verwenden](examples-s3-transfermanager.md)

# Buckets erstellen, auflisten und löschen
<a name="examples-s3-buckets"></a>

Jedes *Objekt* oder jede Datei in Amazon Simple Storage Service (Amazon S3) ist in einem *Bucket* enthalten, der einen Ordner mit Objekten darstellt. Jeder Bucket hat einen Namen, der innerhalb eines Buckets weltweit einzigartig ist AWS. Weitere Informationen finden Sie unter [Arbeiten mit Amazon S3 S3-Buckets](https://docs.aws.amazon.com/AmazonS3/latest/dev/UsingBucket.html) im Amazon Simple Storage Service-Benutzerhandbuch.

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

Bevor Sie beginnen, empfehlen wir Ihnen, [Erste Schritte mit dem AWS SDK für C\$1\$1 zu](getting-started.md) lesen. 

Laden Sie den Beispielcode herunter und erstellen Sie die Lösung wie unter beschrieben[Erste Schritte mit Codebeispielen](getting-started-code-examples.md). 

Um die Beispiele ausführen zu können, muss das Benutzerprofil, das Ihr Code für die Anfragen verwendet, über die entsprechenden Berechtigungen verfügen AWS (für den Dienst und die Aktion). Weitere Informationen finden Sie unter [Bereitstellen von AWS Anmeldeinformationen](credentials.md).

## Buckets auflisten
<a name="list-buckets"></a>

Um das `list_buckets` Beispiel auszuführen, navigieren Sie an einer Befehlszeile zu dem Ordner, in dem Ihr Build-System Ihre ausführbaren Build-Dateien erstellt. Führen Sie die ausführbare Datei wie folgt aus `run_list_buckets` (der vollständige Dateiname der ausführbaren Datei hängt von Ihrem Betriebssystem ab). In der Ausgabe werden die Buckets Ihres Kontos aufgeführt, falls Sie welche haben, oder es wird eine leere Liste angezeigt, wenn Sie keine Buckets haben.

Darin gibt `list_buckets.cpp` es zwei Methoden.
+ `main()`Anrufe`ListBuckets()`. 
+ `ListBuckets()`verwendet das SDK, um Ihre Buckets abzufragen.

Das `S3Client` Objekt ruft die `ListBuckets()` Methode des SDK auf. Bei Erfolg gibt die Methode ein `ListBucketOutcome` Objekt zurück, das ein `ListBucketResult` Objekt enthält. Das `ListBucketResult` Objekt ruft die `GetBuckets()` Methode auf, um eine Liste von `Bucket` Objekten abzurufen, die Informationen zu jedem Amazon S3 S3-Bucket in Ihrem Konto enthalten.

 **Code** 

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

    auto outcome = client.ListBuckets();

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

    return result;
}
```

Das vollständige [list\$1buckets-Beispiel finden Sie auf Github](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code/s3/list_buckets.cpp).

## Erstellen eines -Buckets
<a name="create-bucket"></a>



Um das `create_bucket` Beispiel auszuführen, navigieren Sie an einer Befehlszeile zu dem Ordner, in dem Ihr Build-System Ihre ausführbaren Build-Dateien erstellt. Führen Sie die ausführbare Datei wie folgt aus `run_create_bucket` (der vollständige Dateiname der ausführbaren Datei hängt von Ihrem Betriebssystem ab). Der Code erstellt einen leeren Bucket unter Ihrem Konto und zeigt dann an, ob die Anfrage erfolgreich war oder nicht.

`create_bucket.cpp`In gibt es zwei Methoden. 
+ `main()`Anrufe`CreateBucket()`. `main()`In müssen Sie die AWS-Region Region Ihres Kontos ändern, indem Sie die verwenden`enum`. Sie können die Region Ihres Kontos einsehen [AWS-Managementkonsole](https://console.aws.amazon.com/), indem Sie sich bei anmelden und die Region in der oberen rechten Ecke suchen. 
+ `CreateBucket()`verwendet das SDK, um einen Bucket zu erstellen. 



Das `S3Client` Objekt ruft die `CreateBucket()` Methode des SDK auf und übergibt eine `CreateBucketRequest` mit dem Namen des Buckets. Standardmäßig werden Buckets in der Region *us-east-1* (Nord-Virginia) erstellt. Wenn Ihre Region nicht *us-east-1* ist, richtet der Code eine Bucket-Einschränkung ein, um sicherzustellen, dass der Bucket in Ihrer Region erstellt wird.

 **Code** 

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

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

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

    return outcome.IsSuccess();
}
```

Das vollständige [create\$1buckets-Beispiel](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code/s3/create_bucket.cpp) finden Sie auf Github.

## Löschen eines -Buckets
<a name="delete-bucket"></a>



Um das `delete_bucket` Beispiel auszuführen, navigieren Sie an einer Befehlszeile zu dem Ordner, in dem Ihr Build-System Ihre ausführbaren Build-Dateien erstellt. Führen Sie die ausführbare Datei wie folgt aus `run_delete_bucket` (der vollständige Dateiname der ausführbaren Datei hängt von Ihrem Betriebssystem ab). Der Code löscht den angegebenen Bucket in Ihrem Konto und zeigt dann an, ob die Anfrage erfolgreich war oder nicht.

Darin `delete_bucket.cpp` gibt es zwei Methoden. 
+ `main()`ruft an`DeleteBucket()`. `main()`In müssen Sie die AWS-Region Region Ihres Kontos ändern, indem Sie die verwenden`enum`. Sie müssen das auch in `bucket_name` den Namen des Buckets ändern, den Sie löschen möchten. 
+ `DeleteBucket()`verwendet das SDK, um den Bucket zu löschen. 



Das `S3Client` Objekt verwendet die `DeleteBucket()` Methode des SDK und übergibt ein `DeleteBucketRequest` Objekt mit dem Namen des zu löschenden Buckets. Der Bucket muss leer sein, um erfolgreich zu sein.

 **Code**

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

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

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

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

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

    return outcome.IsSuccess();
}
```

Das vollständige [delete\$1bucket-Beispiel](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code/s3/delete_bucket.cpp) finden Sie auf Github.

# Operationen für Objekte
<a name="examples-s3-objects"></a>

Ein Amazon S3 S3-Objekt stellt eine *Datei* dar, bei der es sich um eine Sammlung von Daten handelt. Jedes Objekt muss in einem [Bucket](examples-s3-buckets.md) enthalten sein.

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

Bevor Sie beginnen, empfehlen wir Ihnen, [Erste Schritte mit dem zu](getting-started.md) lesen AWS SDK für C\$1\$1. 

Laden Sie den Beispielcode herunter und erstellen Sie die Lösung wie unter beschrieben[Erste Schritte mit Codebeispielen](getting-started-code-examples.md). 

Um die Beispiele ausführen zu können, muss das Benutzerprofil, das Ihr Code für die Anfragen verwendet, über die entsprechenden Berechtigungen verfügen AWS (für den Dienst und die Aktion). Weitere Informationen finden Sie unter [Bereitstellen von AWS Anmeldeinformationen](credentials.md).

## Laden Sie eine Datei in einen Bucket hoch
<a name="upload-object"></a>

Verwenden Sie die `S3Client` `PutObject` Objektfunktion und geben Sie ihr einen Bucket-Namen, einen Schlüsselnamen und eine hochzuladende Datei. `Aws::FStream`wird verwendet, um den Inhalt der lokalen Datei in den Bucket hochzuladen. Der Bucket muss existieren, andernfalls tritt ein Fehler auf.

Ein Beispiel für das asynchrone Hochladen von Objekten finden Sie unter [Asynchrone Programmierung mit dem AWS SDK für C\$1\$1](async-methods.md)

 **Code** 

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

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

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

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

    request.SetBody(inputData);

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

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

    return outcome.IsSuccess();
}
```

Auf GitHub finden Sie ein [vollständiges Beispiel](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code/s3/put_object.cpp).

## Laden Sie eine Zeichenfolge in einen Bucket hoch
<a name="upload-object-string"></a>

Verwenden Sie die `S3Client` `PutObject` Objektfunktion und geben Sie ihr einen Bucket-Namen, einen Schlüsselnamen und eine hochzuladende Datei. Der Bucket muss existieren, andernfalls tritt ein Fehler auf. Dieses Beispiel unterscheidet sich vom vorherigen dadurch, dass es verwendet wird`Aws::StringStream`, um ein speicherinternes String-Datenobjekt direkt in einen Bucket hochzuladen.

Ein Beispiel für das asynchrone Hochladen von Objekten finden Sie unter [Asynchrone Programmierung mit dem AWS SDK für C\$1\$1](async-methods.md)

 **Code** 

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

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

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

    request.SetBody(inputData);

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

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

    return outcome.IsSuccess();
}
```

Auf GitHub finden Sie ein [vollständiges Beispiel](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code/s3/put_object_buffer.cpp).

## List objects
<a name="list-objects"></a>

Verwenden Sie die Objektfunktion, um eine Liste der Objekte in einem Bucket abzurufen`S3Client`. `ListObjects` Geben Sie ihr ein`ListObjectsRequest`, das Sie mit dem Namen eines Buckets angegeben haben, dessen Inhalt Sie auflisten möchten.

Die `ListObjects` Funktion gibt ein `ListObjectsOutcome` Objekt zurück, mit dem Sie eine Liste von Objekten in Form von `Object` Instanzen abrufen können.

 **Code** 

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

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

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

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

        auto outcome = s3Client.ListObjectsV2(request);

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

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

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

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

    return true;
}
```

Auf GitHub finden Sie ein [vollständiges Beispiel](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code/s3/list_objects.cpp).

## Herunterladen eines Objekts
<a name="download-object"></a>

Verwenden Sie die `S3Client` `GetObject` Objektfunktion und übergeben Sie ihr eine`GetObjectRequest`, die Sie mit dem Namen eines Buckets und dem Objektschlüssel zum Herunterladen festgelegt haben. `GetObject`gibt ein [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)Objekt zurück, das aus 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)und a besteht [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`kann verwendet werden, um auf die Daten des S3-Objekts zuzugreifen.

Das folgende Beispiel lädt ein Objekt von Amazon S3 herunter. Der Objektinhalt wird in einer lokalen Variablen gespeichert und die erste Zeile des Inhalts wird an die Konsole ausgegeben.

 **Code** 

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

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

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

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

    return outcome.IsSuccess();
}
```

Auf GitHub finden Sie ein [vollständiges Beispiel](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code/s3/get_object.cpp).

## Ein Objekt löschen
<a name="delete-object"></a>

Verwenden Sie die `DeleteObject` Funktion des `S3Client` Objekts und übergeben Sie ihm eine`DeleteObjectRequest`, die Sie mit dem Namen eines Buckets und eines Objekts zum Herunterladen festgelegt haben. *Der angegebene Bucket und der Objektschlüssel müssen existieren, andernfalls tritt ein Fehler auf*.

 **Code** 

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

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

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

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

    return outcome.IsSuccess();
}
```

Auf GitHub finden Sie ein [vollständiges Beispiel](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code/s3/delete_object.cpp).

# Amazon S3 S3-Zugriffsberechtigungen verwalten
<a name="examples-s3-access-permissions"></a>

Zugriffsberechtigungen für einen Amazon S3 S3-Bucket oder ein Amazon S3-Objekt werden in einer Zugriffskontrollliste (ACL) definiert. Die ACL gibt den Eigentümer der Grants bucket/object und eine Liste der Grants an. Jede Grant gibt einen Benutzer (oder Empfänger) und die Zugriffsberechtigungen des Benutzers auf den Bucket/das Objekt an, z. B. READ- oder WRITE-Zugriff.

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

Bevor Sie beginnen, empfehlen wir Ihnen, [Erste Schritte mit dem zu](getting-started.md) lesen. AWS SDK für C\$1\$1

Laden Sie den Beispielcode herunter und erstellen Sie die Lösung wie unter beschrieben[Erste Schritte mit Codebeispielen](getting-started-code-examples.md). 

Um die Beispiele ausführen zu können, muss das Benutzerprofil, das Ihr Code für die Anfragen verwendet, über die entsprechenden Berechtigungen verfügen AWS (für den Dienst und die Aktion). Weitere Informationen finden Sie unter [Bereitstellen von AWS Anmeldeinformationen](credentials.md).

## Die Zugriffskontrollliste eines Objekts verwalten
<a name="manage-an-object-s-access-control-list"></a>

Die Zugriffskontrollliste für ein Objekt kann durch Aufrufen der `S3Client` Methode abgerufen werden`GetObjectAcl`. Die Methode akzeptiert die Namen des Objekts und seines Buckets. Der Rückgabewert beinhaltet die ACLs `Owner` und eine Liste von`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";
    }
}
```

Die ACL kann geändert werden, indem entweder eine neue ACL erstellt oder die in der aktuellen ACL angegebenen Grants geändert werden. Die aktualisierte ACL wird zur neuen aktuellen ACL, indem sie an die `PutObjectAcl` Methode übergeben wird.

Der folgende Code verwendet die von abgerufene ACL `GetObjectAcl` und fügt ihr einen neuen Grant hinzu. Der Benutzer oder Empfänger erhält die READ-Berechtigung für das Objekt. Die geänderte ACL wird an übergeben `PutObjectAcl` und ist somit die neue aktuelle ACL. 

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

Auf GitHub finden Sie ein [vollständiges Beispiel](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code/s3/get_put_object_acl.cpp).

## Die Zugriffskontrollliste eines Buckets verwalten
<a name="manage-a-bucket-s-access-control-list"></a>

In den meisten Fällen besteht die bevorzugte Methode zur Festlegung der Zugriffsberechtigungen für einen Bucket darin, eine Bucket-Richtlinie zu definieren. Buckets unterstützen jedoch auch Zugriffskontrolllisten für Benutzer, die sie verwenden möchten.

Die Verwaltung einer Zugriffskontrollliste für einen Bucket ist identisch mit der für ein Objekt verwendeten. Die `GetBucketAcl` Methode ruft die aktuelle ACL eines Buckets ab und `PutBucketAcl` wendet eine neue ACL auf den Bucket an.

Der folgende Code zeigt, wie eine Bucket-ACL abgerufen und festgelegt wird.

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

Auf GitHub finden Sie ein [vollständiges Beispiel](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code/s3/get_put_bucket_acl.cpp).

# Verwaltung des Zugriffs auf Amazon S3 S3-Buckets mithilfe von Bucket-Richtlinien
<a name="examples-s3-bucket-policies"></a>

Sie können eine *Bucket-Richtlinie* einrichten, abrufen oder löschen, um den Zugriff auf Ihre Amazon S3 S3-Buckets zu verwalten.

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

Bevor Sie beginnen, empfehlen wir Ihnen, [Erste Schritte mit dem AWS SDK für C\$1\$1 zu](getting-started.md) lesen. 

Laden Sie den Beispielcode herunter und erstellen Sie die Lösung wie unter beschrieben[Erste Schritte mit Codebeispielen](getting-started-code-examples.md). 

Um die Beispiele ausführen zu können, muss das Benutzerprofil, das Ihr Code für die Anfragen verwendet, über die entsprechenden Berechtigungen verfügen AWS (für den Dienst und die Aktion). Weitere Informationen finden Sie unter [Bereitstellen von AWS Anmeldeinformationen](credentials.md).

## Festlegen einer Bucket-Richtlinie
<a name="set-s3-bucket-policy"></a>

Sie können die Bucket-Richtlinie für einen bestimmten S3-Bucket festlegen, indem Sie die `PutBucketPolicy` Funktion `S3Client`'s aufrufen und ihr den Bucket-Namen und die JSON-Repräsentation der Richtlinie in a zur Verfügung stellen [PutBucketPolicyRequest](https://docs.aws.amazon.com/sdk-for-cpp/latest/api/aws-cpp-sdk-s3/html/class_aws_1_1_s3_1_1_model_1_1_put_bucket_policy_request.html).

 **Code** 

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

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

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

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

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

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

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

    return outcome.IsSuccess();
}
```

**Anmerkung**  
Die JsonValue Utility-Klasse [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) kann Ihnen dabei helfen, gültige JSON-Objekte zu erstellen, an die Sie übergeben werden können. `PutBucketPolicy`

Auf GitHub finden Sie ein [vollständiges Beispiel](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code/s3/put_bucket_policy.cpp).

## Abrufen einer Bucket-Richtlinie
<a name="get-s3-bucket-policy"></a>

Um die Richtlinie für einen Amazon S3 S3-Bucket abzurufen, rufen Sie die `GetBucketPolicy` Funktion `S3Client`'s auf und übergeben ihr den Namen des Buckets in [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)a.

 **Code** 

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

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

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

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

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

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

    return outcome.IsSuccess();
}
```

Auf GitHub finden Sie ein [vollständiges Beispiel](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code/s3/get_bucket_policy.cpp).

## Löschen einer Bucket-Richtlinie
<a name="delete-s3-bucket-policy"></a>

Um eine Bucket-Richtlinie zu löschen, rufen Sie die `DeleteBucketPolicy` Funktion `S3Client`'s auf und geben Sie ihr den Bucket-Namen in einer [DeleteBucketPolicyRequest](https://docs.aws.amazon.com/sdk-for-cpp/latest/api/aws-cpp-sdk-s3/html/class_aws_1_1_s3_1_1_model_1_1_delete_bucket_policy_request.html).

 **Code** 

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

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

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

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

    return outcome.IsSuccess();
}
```

Diese Funktion ist auch dann erfolgreich, wenn der Bucket noch keine Richtlinie hat. Wenn Sie den Namen eines Buckets angeben, der noch nicht vorhanden ist oder für den Sie keinen Zugriff haben, wird eine `AmazonServiceException` ausgelöst.

Auf GitHub finden Sie ein [vollständiges Beispiel](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code/s3/delete_bucket_policy.cpp).

## Weitere Infos
<a name="more-info"></a>
+  [PutBucketPolicy](https://docs.aws.amazon.com/AmazonS3/latest/API/PutBucketPolicy.html)in der Amazon Simple Storage Service API-Referenz
+  [GetBucketPolicy](https://docs.aws.amazon.com/AmazonS3/latest/API/GetBucketPolicy.html)in der Amazon Simple Storage Service API-Referenz
+  [DeleteBucketPolicy](https://docs.aws.amazon.com/AmazonS3/latest/API/DeleteBucketPolicy.html)in der Amazon Simple Storage Service API-Referenz
+  [Sprachübersicht der Zugriffsrichtlinien](https://docs.aws.amazon.com/AmazonS3/latest/dev/access-policy-language-overview.html) im Amazon Simple Storage Service-Benutzerhandbuch
+  [Beispiele für Bucket-Richtlinien](https://docs.aws.amazon.com/AmazonS3/latest/dev/example-bucket-policies.html) im Amazon Simple Storage Service-Benutzerhandbuch

# Konfiguration eines Amazon S3 S3-Buckets als Website
<a name="examples-s3-website-configuration"></a>

Sie können einen Amazon S3 S3-Bucket so konfigurieren, dass er sich wie eine Website verhält. Hierzu müssen Sie die Website-Konfiguration festlegen.

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

Bevor Sie beginnen, empfehlen wir Ihnen, [Erste Schritte mit dem zu](getting-started.md) lesen AWS SDK für C\$1\$1. 

Laden Sie den Beispielcode herunter und erstellen Sie die Lösung wie unter beschrieben[Erste Schritte mit Codebeispielen](getting-started-code-examples.md). 

Um die Beispiele ausführen zu können, muss das Benutzerprofil, das Ihr Code für die Anfragen verwendet, über die entsprechenden Berechtigungen verfügen AWS (für den Dienst und die Aktion). Weitere Informationen finden Sie unter [Bereitstellen von AWS Anmeldeinformationen](credentials.md).

## Festlegen der Website-Konfiguration eines Buckets
<a name="set-a-bucket-s-website-configuration"></a>

Um die Website-Konfiguration eines Amazon S3 S3-Buckets festzulegen, rufen Sie die `S3Client` `PutBucketWebsite` Funktion mit einem [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)Objekt auf, das den Bucket-Namen und seine Website-Konfiguration enthält, die in einem [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)Objekt bereitgestellt werden.

Das Festlegen eines Index-Dokuments ist *erforderlich*. Alle anderen Parameter sind optional.

 **Code** 

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

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

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

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

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

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

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

    return outcome.IsSuccess();
}
```

**Anmerkung**  
Beim Festlegen einer Website-Konfiguration werden die Zugriffsberechtigungen für den Bucket nicht geändert. Um die enthaltenen Dateien im Internet sichtbar zu machen, müssen Sie zusätzlich eine *Bucket-Richtlinie* festlegen, durch die der öffentliche Lesezugriff für die Dateien in dem Bucket ermöglicht wird. Weitere Informationen finden Sie unter [Verwalten des Zugriffs auf Amazon S3-Buckets mit Bucket-Richtlinien](examples-s3-bucket-policies.md).

Auf GitHub finden Sie ein [vollständiges Beispiel](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code/s3/put_website_config.cpp).

## Abruf der Website-Konfiguration eines Buckets
<a name="get-a-bucket-s-website-configuration"></a>

Um die Website-Konfiguration eines Amazon S3 S3-Buckets abzurufen, rufen Sie die `S3Client` `GetBucketWebsite` Funktion mit einem auf, das den Namen des Buckets [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)enthält, für den die Konfiguration abgerufen werden soll.

Die Konfiguration wird als [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)Objekt innerhalb des Ergebnisobjekts zurückgegeben. Wenn keine Website-Konfiguration für den Bucket vorhanden ist, wird `null` zurückgegeben.

 **Code** 

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

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

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

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

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

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

    return outcome.IsSuccess();
}
```

Auf GitHub finden Sie ein [vollständiges Beispiel](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code/s3/get_website_config.cpp).

## Löschen der Website-Konfiguration eines Buckets
<a name="delete-a-bucket-s-website-configuration"></a>

Um die Website-Konfiguration eines Amazon S3 S3-Buckets zu löschen, rufen Sie die `DeleteBucketWebsite` Funktion `S3Client` s mit einem [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): auf, das den Namen des Buckets enthält, aus dem die Konfiguration gelöscht werden soll.

 **Code** 

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

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

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

    return outcome.IsSuccess();
}
```

Auf GitHub finden Sie ein [vollständiges Beispiel](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code/s3/delete_website_config.cpp).

## Weitere Informationen
<a name="more-information"></a>
+  [PUT Bucket-Website](https://docs.aws.amazon.com/AmazonS3/latest/API/RESTBucketPUTwebsite.html) in der Amazon Simple Storage Service API-Referenz
+  [GET Bucket-Website](https://docs.aws.amazon.com/AmazonS3/latest/API/RESTBucketGETwebsite.html) in der Amazon Simple Storage Service API-Referenz
+  [DELETE Bucket-Website](https://docs.aws.amazon.com/AmazonS3/latest/API/RESTBucketDELETEwebsite.html) in der Amazon Simple Storage Service API-Referenz

# TransferManager Für Amazon S3 S3-Operationen verwenden
<a name="examples-s3-transfermanager"></a>

Sie können die AWS SDK für C\$1\$1 `TransferManager` Klasse verwenden, um Dateien zuverlässig aus der lokalen Umgebung nach Amazon S3 zu übertragen und Objekte von einem Amazon S3 S3-Standort an einen anderen zu kopieren. `TransferManager`kann den Fortschritt einer Übertragung abrufen und Uploads und Downloads pausieren oder fortsetzen.

**Anmerkung**  
Um zu vermeiden, dass unvollständige oder teilweise Uploads in Rechnung gestellt werden, empfehlen wir Ihnen, die [AbortIncompleteMultipartUpload](https://docs.aws.amazon.com/AmazonS3/latest/userguide/mpu-abort-incomplete-mpu-lifecycle-config.html)Lebenszyklusregel für Ihre Amazon S3 S3-Buckets zu aktivieren.  
Diese Regel weist Amazon S3 an, mehrteilige Uploads abzubrechen, die nicht innerhalb einer bestimmten Anzahl von Tagen nach der Initiierung abgeschlossen werden. Wenn das festgelegte Zeitlimit überschritten wird, bricht Amazon S3 den Upload ab und löscht dann die unvollständigen Upload-Daten.   
Weitere Informationen finden Sie unter [Einstellung der Lebenszykluskonfiguration für einen Bucket](https://docs.aws.amazon.com/AmazonS3/latest/userguide/how-to-set-lifecycle-configuration-intro.html) im Amazon S3 S3-Benutzerhandbuch.

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

Bevor Sie beginnen, empfehlen wir Ihnen, [Erste Schritte mit dem zu](getting-started.md) lesen AWS SDK für C\$1\$1. 

Laden Sie den Beispielcode herunter und erstellen Sie die Lösung wie unter beschrieben[Erste Schritte mit Codebeispielen](getting-started-code-examples.md). 

Um die Beispiele ausführen zu können, muss das Benutzerprofil, das Ihr Code für die Anfragen verwendet, über die entsprechenden Berechtigungen verfügen AWS (für den Dienst und die Aktion). Weitere Informationen finden Sie unter [Bereitstellen von AWS Anmeldeinformationen](credentials.md).

## Objekt hoch- und herunterladen mit `TransferManager`
<a name="stream"></a>

Dieses Beispiel zeigt, wie große Objekte im Speicher [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)übertragen werden. `UploadFile`und `DownloadFile` Methoden werden beide asynchron aufgerufen und geben a zurück`TransferHandle`, um den Status Ihrer Anfrage zu verwalten. Wenn das hochgeladene Objekt größer als `bufferSize` dann ist, wird ein mehrteiliger Upload durchgeführt. Die `bufferSize` Standardeinstellung ist 5 MB, dies kann jedoch über konfiguriert werden. [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;
```

Auf GitHub finden Sie ein [vollständiges Beispiel](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code/transfer-manager/transferOnStream.cpp).

# `S3CrtClient`Für Amazon S3 S3-Operationen verwenden
<a name="examples-s3-crt"></a>

Die `S3CrtClient` Klasse ist in Version 1.9 von verfügbar AWS SDK für C\$1\$1 und verbessert den Durchsatz beim Hoch- und Herunterladen großer Datendateien zu und von Amazon S3. Weitere Informationen zu den Verbesserungen dieser Version finden Sie unter [Verbessern des Amazon S3 S3-Durchsatzes mit Version AWS SDK für C\$1\$1 1.9](https://github.com/aws/aws-sdk-cpp/wiki/Improving-S3-Throughput-with-AWS-SDK-for-CPP-v1.9)

Das `S3CrtClient` ist auf der Grundlage der [AWS Common Runtime (CRT)](https://docs.aws.amazon.com/sdkref/latest/guide/common-runtime.html) -Bibliotheken implementiert.

**Anmerkung**  
Um zu vermeiden, dass unvollständige oder teilweise Uploads in Rechnung gestellt werden, empfehlen wir Ihnen, die [AbortIncompleteMultipartUpload](https://docs.aws.amazon.com/AmazonS3/latest/userguide/mpu-abort-incomplete-mpu-lifecycle-config.html)Lebenszyklusregel für Ihre Amazon S3 S3-Buckets zu aktivieren.  
Diese Regel weist Amazon S3 an, mehrteilige Uploads abzubrechen, die nicht innerhalb einer bestimmten Anzahl von Tagen nach der Initiierung abgeschlossen werden. Wenn das festgelegte Zeitlimit überschritten wird, bricht Amazon S3 den Upload ab und löscht dann die unvollständigen Upload-Daten.   
Weitere Informationen finden Sie unter [Einstellung der Lebenszykluskonfiguration für einen Bucket](https://docs.aws.amazon.com/AmazonS3/latest/userguide/how-to-set-lifecycle-configuration-intro.html) im Amazon S3 S3-Benutzerhandbuch.

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

Bevor Sie beginnen, empfehlen wir Ihnen, [Erste Schritte mit dem zu](getting-started.md) lesen AWS SDK für C\$1\$1. 

Laden Sie den Beispielcode herunter und erstellen Sie die Lösung wie unter beschrieben[Erste Schritte mit Codebeispielen](getting-started-code-examples.md). 

Um die Beispiele ausführen zu können, muss das Benutzerprofil, das Ihr Code für die Anfragen verwendet, über die entsprechenden Berechtigungen verfügen AWS (für den Dienst und die Aktion). Weitere Informationen finden Sie unter [Bereitstellen von AWS Anmeldeinformationen](credentials.md).

## Objekt hoch- und herunterladen mit `S3CrtClient`
<a name="stream"></a>

Dieses Beispiel zeigt, wie Sie den verwenden [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). Das Beispiel erstellt einen Bucket, lädt ein Objekt hoch, lädt das Objekt herunter und löscht dann die Datei und den Bucket. Eine PUT-Operation wird zu einem mehrteiligen Upload. Aus einer GET-Operation werden mehrere GET-Anfragen mit „Bereichsbereich“. Weitere Informationen zu mehrteiligen Uploads finden Sie unter [Hochladen und Kopieren von Objekten mithilfe des mehrteiligen Uploads](https://docs.aws.amazon.com/AmazonS3/latest/userguide/mpuoverview.html) im Amazon S3 S3-Benutzerhandbuch. 

Die bereitgestellte Datendatei,`ny.json`, wird in diesem Beispiel als mehrteiliger Upload hochgeladen. Dies kann nach einer erfolgreichen Ausführung des Programms anhand der Debug-Protokolle bestätigt werden.

Schlägt der Upload fehl, `AbortMultipartUpload` wird eine in der zugrunde liegenden CRT-Bibliothek ausgegeben, um alle bereits hochgeladenen Teile zu bereinigen. Allerdings können nicht alle Fehler intern behoben werden (z. B. wenn ein Netzwerkkabel abgezogen wird). Es wird empfohlen, eine Lebenszyklusregel für Ihren Amazon S3 S3-Bucket zu erstellen, um sicherzustellen, dass teilweise hochgeladene Daten nicht in Ihrem Konto verbleiben (teilweise hochgeladene Daten sind weiterhin fakturierbar). Informationen zum Einrichten einer Lebenszyklusregel finden Sie unter [Erkennen und Löschen unvollständiger mehrteiliger Uploads zur Senkung der Amazon S3 S3-Kosten](https://aws.amazon.com/blogs/aws-cost-management/discovering-and-deleting-incomplete-multipart-uploads-to-lower-amazon-s3-costs/ ). 

**Verwenden Sie das Debug-Protokoll, um Details zu mehrteiligen Uploads zu untersuchen**

1. Beachten Sie`main()`, dass es "TODO" Kommentare mit Anweisungen zur Aktualisierung des Codes gibt.

   1. Für`file_name`: Laden Sie über den Link im Codekommentar eine Beispieldatendatei herunter`ny.json`, oder verwenden Sie eine eigene große Datendatei.

   1. Für`region`: Aktualisieren Sie die `region` Variable mithilfe der Enumeration auf die AWS-Region Ihres Kontos. Um die Region Ihres Kontos zu finden, melden Sie sich bei an und suchen Sie die Region in der oberen rechten Ecke. AWS-Managementkonsole

1. Erstellen Sie das Beispiel.

1. Kopieren Sie die durch die Variable angegebene Datei `file_name` in Ihren ausführbaren Ordner und führen Sie die `s3-crt-demo` ausführbare Datei aus.

1. Suchen Sie in Ihrem ausführbaren Ordner nach der neuesten `.log` Datei.

1. Öffnen Sie die Protokolldatei, wählen Sie **Suchen** und geben Sie die Eingabetaste ein**partNumber**.

1. Das Protokoll enthält Einträge, die den folgenden ähneln, wobei die `partNumber` und für jeden Teil der hochgeladenen Datei angegeben `uploadId` sind:

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

    und 

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

Auf GitHub finden Sie ein [vollständiges Beispiel](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code/s3-crt/s3-crt-demo.cpp).

# Amazon SQS SQS-Codebeispiele mit dem AWS SDK für C\$1\$1
<a name="examples-sqs"></a>

Amazon Simple Queue Service (Amazon SQS) ist ein vollständig verwalteter Message Queuing-Service, der es einfach macht, Microservices, verteilte Systeme und serverlose Anwendungen zu entkoppeln und zu skalieren. Sie können die folgenden Beispiele verwenden, um [Amazon SQS](https://aws.amazon.com/sqs) mit dem AWS SDK für C\$1\$1 zu programmieren.

**Anmerkung**  
In diesem Handbuch ist nur der Code enthalten, der zur Veranschaulichung bestimmter Techniken erforderlich ist. Der [vollständige Beispielcode ist jedoch unter GitHub verfügbar](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp). Auf können GitHub Sie eine einzelne Quelldatei herunterladen oder das Repository lokal klonen, um alle Beispiele abzurufen, zu erstellen und auszuführen.

**Topics**
+ [Mit Amazon SQS Message Queues arbeiten](examples-sqs-message-queues.md)
+ [Senden, Empfangen und Löschen von Amazon SQS SQS-Nachrichten](examples-sqs-messages.md)
+ [Long Polling für Amazon SQS SQS-Nachrichtenwarteschlangen aktivieren](examples-sqs-long-polling.md)
+ [Einstellen des Sichtbarkeits-Timeouts in Amazon SQS](examples-sqs-visibility-timeout.md)
+ [Verwenden von Warteschlangen für unzustellbare Nachrichten in Amazon SQS](examples-sqs-dead-letter-queues.md)

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

Eine *Nachrichtenwarteschlange* ist der logische Container, den Sie verwenden, um Nachrichten zuverlässig in Amazon SQS zu versenden. Es gibt zwei Arten von Warteschlangen: *Standard* und *First-in-First-out-Verfahren* (FIFO). Weitere Informationen zu Warteschlangen und den Unterschieden zwischen diesen Typen finden Sie im [Amazon Simple Queue Service Developer Guide](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/).

Diese C\$1\$1-Beispiele zeigen Ihnen, wie Sie die verwenden, AWS SDK für C\$1\$1 um eine Amazon SQS SQS-Warteschlange zu erstellen, aufzulisten, zu löschen und deren URL abzurufen.

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

Bevor Sie beginnen, empfehlen wir Ihnen, [Erste Schritte mit dem AWS SDK für C\$1\$1 zu](getting-started.md) lesen. 

Laden Sie den Beispielcode herunter und erstellen Sie die Lösung wie unter beschrieben[Erste Schritte mit Codebeispielen](getting-started-code-examples.md). 

Um die Beispiele ausführen zu können, muss das Benutzerprofil, das Ihr Code für die Anfragen verwendet, über die entsprechenden Berechtigungen verfügen AWS (für den Dienst und die Aktion). Weitere Informationen finden Sie unter [Bereitstellen von AWS Anmeldeinformationen](credentials.md).

## Erstellen einer Warteschlange
<a name="sqs-create-queue"></a>

Verwenden Sie die SQSClient `CreateQueue` Klassenmitgliedsfunktion und stellen Sie ihr ein [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)Objekt zur Verfügung, das die Warteschlangenparameter beschreibt.

 **Beinhaltet** 

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

 **Code** 

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

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

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

Siehe [vollständiges Beispiel](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code/sqs/create_queue.cpp).

## Auflisten von Warteschlangen
<a name="sqs-list-queues"></a>

Um Amazon SQS SQS-Warteschlangen für Ihr Konto aufzulisten, rufen Sie die SQSClient `ListQueues` Klassenmitgliedsfunktion auf und übergeben Sie ihr ein [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)Objekt.

 **Beinhaltet** 

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

 **Code** 

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

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

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

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

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

    } while (!nextToken.empty());

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

Siehe [vollständiges Beispiel](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code/sqs/list_queues.cpp).

## Ruft die URL der Warteschlange ab
<a name="sqs-get-queue-url"></a>

Rufen Sie die SQSClient `GetQueueUrl` Klassenmitgliedsfunktion auf, um die URL für eine bestehende Amazon SQS SQS-Warteschlange abzurufen.

 **Beinhaltet** 

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

 **Code** 

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

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

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

Siehe [vollständiges Beispiel](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code/sqs/get_queue_url.cpp).

## Löschen einer Warteschlange
<a name="sqs-delete-queue"></a>

Geben Sie die [URL](#sqs-get-queue-url) zur SQSClient `DeleteQueue` Klassenmitgliedsfunktion an.

 **Beinhaltet** 

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

 **Code** 

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

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

Siehe [vollständiges Beispiel](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code/sqs/delete_queue.cpp).

## Weitere Infos
<a name="more-info"></a>
+  [So funktionieren Amazon SQS SQS-Warteschlangen](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/sqs-how-it-works.html) im Amazon Simple Queue Service Developer Guide
+  [CreateQueue](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/API_CreateQueue.html)in der Amazon Simple Queue Service API-Referenz
+  [GetQueueUrl](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/API_GetQueueUrl.html)in der Amazon Simple Queue Service API-Referenz
+  [ListQueues](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/API_ListQueues.html)in der Amazon Simple Queue Service API-Referenz
+  [DeleteQueues](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/API_DeleteQueues.html)in der Amazon Simple Queue Service API-Referenz

# Senden, Empfangen und Löschen von Amazon SQS SQS-Nachrichten
<a name="examples-sqs-messages"></a>

Nachrichten werden immer über eine [SQS-Warteschlange](examples-sqs-message-queues.md) zugestellt. Diese C\$1\$1-Beispiele zeigen Ihnen, wie Sie Amazon SQS-Nachrichten aus SQS-Warteschlangen senden, empfangen und löschen können. AWS SDK für C\$1\$1 

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

Bevor Sie beginnen, empfehlen wir Ihnen, [Erste Schritte mit dem zu](getting-started.md) lesen. AWS SDK für C\$1\$1

Laden Sie den Beispielcode herunter und erstellen Sie die Lösung wie unter beschrieben[Erste Schritte mit Codebeispielen](getting-started-code-examples.md). 

Um die Beispiele ausführen zu können, muss das Benutzerprofil, das Ihr Code für die Anfragen verwendet, über die entsprechenden Berechtigungen verfügen AWS (für den Dienst und die Aktion). Weitere Informationen finden Sie unter [Bereitstellen von AWS Anmeldeinformationen](credentials.md).

## Senden einer Nachricht
<a name="sqs-message-send"></a>

Sie können einer Amazon SQS SQS-Warteschlange eine einzelne Nachricht hinzufügen, indem Sie die SQSClient `SendMessage` Klassenmitgliedsfunktion aufrufen. Sie stellen `SendMessage` ein [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)Objekt bereit, das die [URL](examples-sqs-message-queues.md#sqs-get-queue-url) der Warteschlange, den Nachrichtentext und einen optionalen Verzögerungswert (in Sekunden) enthält.

 **Beinhaltet** 

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

 **Code** 

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

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

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

Siehe [vollständiges Beispiel](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code/sqs/send_message.cpp).

## Empfangen von Nachrichten
<a name="sqs-messages-receive"></a>

Ruft alle Nachrichten ab, die sich derzeit in der Warteschlange befinden, indem Sie die SQSClient `ReceiveMessage` Klassenmitgliedsfunktion aufrufen und ihr die URL der Warteschlange übergeben. Nachrichten werden als Liste von [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)-Objekten zurückgegeben.

 **Beinhaltet** 

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

 **Code** 

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

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

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

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

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

Siehe [vollständiges Beispiel](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code/sqs/receive_message.cpp).

### Löschen von Nachrichten nach dem Empfangen
<a name="sqs-messages-delete"></a>

Nachdem Sie eine Nachricht empfangen und ihren Inhalt verarbeitet haben, löschen Sie die Nachricht aus der Warteschlange, indem Sie das Empfangs-Handle der Nachricht und die Warteschlangen-URL an die SQSClient `DeleteMessage` Klassenmitgliedsfunktion senden.

 **Beinhaltet** 

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

 **Code** 

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

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

Siehe [vollständiges Beispiel](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code/sqs/receive_message.cpp).

## Weitere Infos
<a name="more-info"></a>
+  [So funktionieren Amazon SQS SQS-Warteschlangen](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/sqs-how-it-works.html) im Amazon Simple Queue Service Developer Guide
+  [SendMessage](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/API_SendMessage.html)in der Amazon Simple Queue Service API-Referenz
+  [SendMessageBatch](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/API_SendMessageBatch.html)in der Amazon Simple Queue Service API-Referenz
+  [ReceiveMessage](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/API_ReceiveMessage.html)in der Amazon Simple Queue Service API-Referenz
+  [DeleteMessage](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/API_DeleteMessage.html)in der Amazon Simple Queue Service API-Referenz

# Long Polling für Amazon SQS SQS-Nachrichtenwarteschlangen aktivieren
<a name="examples-sqs-long-polling"></a>

Amazon SQS verwendet standardmäßig *kurze Abfragen*, bei denen nur eine Teilmenge der Server abgefragt wird — basierend auf einer gewichteten Zufallsverteilung —, um festzustellen, ob Nachrichten für die Antwort verfügbar sind.

Lange Abfragen tragen dazu bei, Ihre Kosten für die Nutzung von Amazon SQS zu senken, indem die Anzahl der leeren Antworten reduziert wird, wenn keine Nachrichten als Antwort auf eine an eine Amazon SQS SQS-Warteschlange gesendete ReceiveMessage Anfrage zurückgesendet werden können, und falsche leere Antworten vermieden werden. Sie können eine Langabfragen-Häufigkeit von *1–20 Sekunden* festlegen.

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

Bevor Sie beginnen, empfehlen wir Ihnen, [Erste Schritte mit dem zu](getting-started.md) lesen. AWS SDK für C\$1\$1

Laden Sie den Beispielcode herunter und erstellen Sie die Lösung wie unter beschrieben[Erste Schritte mit Codebeispielen](getting-started-code-examples.md). 

Um die Beispiele ausführen zu können, muss das Benutzerprofil, das Ihr Code für die Anfragen verwendet, über die entsprechenden Berechtigungen verfügen AWS (für den Dienst und die Aktion). Weitere Informationen finden Sie unter [Bereitstellen von AWS Anmeldeinformationen](credentials.md).

## Aktivieren Sie Long Polling beim Erstellen einer Warteschlange
<a name="sqs-long-polling-create-queue"></a>

Um lange Abfragen beim Erstellen einer Amazon SQS SQS-Warteschlange zu aktivieren, legen Sie das `ReceiveMessageWaitTimeSeconds` Attribut für das [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)Objekt fest, bevor Sie die Mitgliedsfunktion der SQSClient Klasse aufrufen. `CreateQueue`

 **Beinhaltet** 

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

 **Code** 

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

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

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

Siehe [vollständiges Beispiel](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code/sqs/long_polling_on_create_queue.cpp).

## Aktivieren der Langabfrage für eine vorhandene Warteschlange
<a name="sqs-long-polling-existing-queue"></a>

Zusätzlich zur Aktivierung der langen Abfrage beim Erstellen einer Warteschlange können Sie diese Funktion auch in einer vorhandenen Warteschlange aktivieren, indem `ReceiveMessageWaitTimeSeconds` Sie die Funktion [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)vor dem Aufrufen der Member-Funktion der SQSClient Klasse aktivieren`SetQueueAttributes`.

 **Beinhaltet** 

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

 **Code** 

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

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

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

Siehe [vollständiges Beispiel](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code/sqs/long_polling_on_existing_queue.cpp).

## Aktivieren von Langabfragen beim Nachrichteneingang
<a name="sqs-long-polling-receive-message"></a>

Sie können lange Abfragen beim Empfang einer Nachricht aktivieren, indem Sie die Wartezeit in Sekunden für den Wert festlegen [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), den Sie an die ReceiveMessage Mitgliedsfunktion der SQSClient Klasse übergeben.

**Anmerkung**  
Sie sollten sicherstellen, dass das Anfrage-Timeout des AWS Clients größer ist als die maximale lange Abfragezeit (20 s), damit Ihre `ReceiveMessage` Anfragen beim Warten auf das nächste Umfrageereignis nicht zu einem Timeout kommen\$1

 **Beinhaltet** 

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

 **Code** 

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

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

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

Siehe [vollständiges Beispiel](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code/sqs/long_polling_on_message_receipt.cpp).

## Weitere Infos
<a name="more-info"></a>
+  [Amazon SQS Long Polling](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/sqs-long-polling.html) im Amazon Simple Queue Service Developer Guide
+  [CreateQueue](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/API_CreateQueue.html)in der Amazon Simple Queue Service API-Referenz
+  [ReceiveMessage](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/API_ReceiveMessage.html)in der Amazon Simple Queue Service API-Referenz
+  [SetQueueAttributes](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/API_SetQueueAttributes.html)in der Amazon Simple Queue Service API-Referenz

# Einstellen des Sichtbarkeits-Timeouts in Amazon SQS
<a name="examples-sqs-visibility-timeout"></a>

Wenn eine Nachricht in Amazon SQS empfangen wird, bleibt sie in der Warteschlange, bis sie gelöscht wird, um den Empfang sicherzustellen. Eine empfangene, aber nicht gelöschte Nachricht erscheint erst nach Ablauf einer bestimmten *Zeitbeschränkung für die Sichtbarkeit* in nachfolgenden Anforderungen. Dadurch wird gewährleistet, dass die Nachricht nicht mehrmals empfangen wird, bevor sie verarbeitet und gelöscht werden kann.

Bei Nutzung von [Standard-Warteschlangen](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/standard-queues.html) kann durch die Zeitbeschränkung für die Sichtbarkeit nicht garantiert werden, dass eine Nachricht mehrmals empfangen wird. Wenn Sie eine Standard-Warteschlange verwenden, achten Sie darauf, dass Ihr Code mit dem Fall umgehen kann, dass dieselbe Nachricht mehrmals eingeht.

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

Bevor Sie beginnen, empfehlen wir Ihnen, [Erste Schritte mit dem AWS SDK für C\$1\$1 zu](getting-started.md) lesen. 

Laden Sie den Beispielcode herunter und erstellen Sie die Lösung wie unter beschrieben[Erste Schritte mit Codebeispielen](getting-started-code-examples.md). 

Um die Beispiele ausführen zu können, muss das Benutzerprofil, das Ihr Code für die Anfragen verwendet, über die entsprechenden Berechtigungen verfügen AWS (für den Dienst und die Aktion). Weitere Informationen finden Sie unter [Bereitstellen von AWS Anmeldeinformationen](credentials.md).

## Legen Sie das Timeout für die Nachrichtensichtbarkeit beim Empfang der Nachricht fest
<a name="sqs-visibility-timeout-receipt"></a>

Wenn Sie eine Nachricht erhalten haben, können Sie das Zeitlimit für die Sichtbarkeit ändern, indem Sie die Empfangsnummer in einer Nachricht übergeben [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), die Sie an die Mitgliederfunktion der SQSClient Klasse übergeben. `ChangeMessageVisibility`

 **Beinhaltet** 

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

 **Code** 

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

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

Siehe [vollständiges Beispiel](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code/sqs/change_message_visibility.cpp).

## Weitere Infos
<a name="more-info"></a>
+  [Visibility Timeout](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/sqs-visibility-timeout.html) im Amazon Simple Queue Service Developer Guide
+  [SetQueueAttributes](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/API_SetQueueAttributes.html)in der Amazon Simple Queue Service API-Referenz
+  [GetQueueAttributes](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/API_GetQueueAttributes.html)in der Amazon Simple Queue Service API-Referenz
+  [ReceiveMessage](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/API_ReceiveMessage.html)in der Amazon Simple Queue Service API-Referenz
+  [ChangeMessageVisibility](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/API_ChangeMessageVisibility.html)in der Amazon Simple Queue Service API-Referenz
+  [ChangeMessageVisibilityBatch](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/API_ChangeMessageVisibilityBatch.html)in der Amazon Simple Queue Service API-Referenz

# Verwenden von Warteschlangen für unzustellbare Nachrichten in Amazon SQS
<a name="examples-sqs-dead-letter-queues"></a>

Amazon SQS bietet Unterstützung für *Warteschlangen mit unbestätigten Briefen*. Eine Warteschlange für unzustellbare Nachrichten ist eine Warteschlange, die von anderen Warteschlangen für Nachrichten ausgewählt werden kann, die nicht erfolgreich verarbeitet werden können. Sie können diese Nachrichten in der Warteschlange für unzustellbare Nachrichten sammeln und isolieren, um zu bestimmen, warum die Verarbeitung fehlgeschlagen ist.

Um eine Warteschlange für unzustellbare Nachrichten zu erstellen, müssen Sie zuerst eine *Redrive-Richtlinie* erstellen und diese dann in den Attributen der Warteschlange festlegen.

**Wichtig**  
Bei einer Warteschlange für unzustellbare Nachrichten muss es sich um dieselbe Art von Warteschlange (FIFO oder Standard) handeln wie bei der Quellwarteschlange. Sie muss außerdem mit demselben AWS-Konto und AWS-Region wie die Quellwarteschlange erstellt werden.

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

Bevor Sie beginnen, empfehlen wir Ihnen, [Erste Schritte mit dem zu](getting-started.md) lesen AWS SDK für C\$1\$1. 

Laden Sie den Beispielcode herunter und erstellen Sie die Lösung wie unter beschrieben[Erste Schritte mit Codebeispielen](getting-started-code-examples.md). 

Um die Beispiele ausführen zu können, muss das Benutzerprofil, das Ihr Code für die Anfragen verwendet, über die entsprechenden Berechtigungen verfügen AWS (für den Dienst und die Aktion). Weitere Informationen finden Sie unter [Bereitstellen von AWS Anmeldeinformationen](credentials.md).

## Erstellen Sie eine Redrive-Richtlinie
<a name="sqs-dead-letter-queue-create-redrive-policy"></a>

Eine Redrive-Richtlinie ist in JSON angegeben. Um sie zu erstellen, können Sie die JSON-Utility-Klasse verwenden, die im AWS SDK für C\$1\$1 Lieferumfang von enthalten ist.

Hier ist eine Beispielfunktion, die eine Redrive-Richtlinie erstellt, indem sie ihr den ARN Ihrer Warteschlange für unzustellbare Briefe und die maximale Häufigkeit, mit der die Nachricht empfangen und nicht verarbeitet werden kann, zur Verfügung stellt, bevor sie an die Warteschlange für unzustellbare Briefe gesendet wird.

 **Beinhaltet** 

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

 **Code** 

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

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

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

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

Siehe [vollständiges Beispiel](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code/sqs/dead_letter_queue.cpp).

## Legen Sie die Redrive-Richtlinie für Ihre Quellwarteschlange fest
<a name="sqs-dead-letter-queue-set-redrive-policy"></a>

Um die Einrichtung Ihrer Warteschlange für unzustellbare Briefe abzuschließen, rufen Sie die SQSClient `SetQueueAttributes` Mitgliederfunktion der Klasse mit einem [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)Objekt auf, für das Sie das `RedrivePolicy` Attribut mit Ihrer JSON-Redrive-Richtlinie festgelegt haben.

 **Beinhaltet** 

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

 **Code** 

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

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

Siehe [vollständiges Beispiel](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code/sqs/dead_letter_queue.cpp).

## Weitere Infos
<a name="more-info"></a>
+  [Verwenden von Amazon SQS Dead Letter Queues](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/sqs-dead-letter-queues.html) im Amazon Simple Queue Service Developer Guide
+  [SetQueueAttributes](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/API_SetQueueAttributes.html)in der Amazon Simple Queue Service API-Referenz