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.

# 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