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