Las traducciones son generadas a través de traducción automática. En caso de conflicto entre la traducción y la version original de inglés, prevalecerá la version en inglés.

# Ejemplos de código de Amazon S3 que utilizan AWS SDK para C\$1\$1
<a name="examples-s3"></a>

[Amazon S3](https://aws.amazon.com/s3) es un servicio de almacenamiento de objetos creado para almacenar y recuperar cualquier volumen de datos desde cualquier ubicación. La interfaz AWS SDK para C\$1\$1 to proporciona varias clases con Amazon S3. 

**nota**  
En esta guía solo se proporciona el código necesario para demostrar determinadas técnicas, pero el [código de ejemplo completo está disponible en GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp). GitHub Puede descargar un único archivo fuente o clonar el repositorio localmente para obtener, compilar y ejecutar todos los ejemplos.
+ Clase [https://docs.aws.amazon.com/sdk-for-cpp/latest/api/aws-cpp-sdk-s3/html/class_aws_1_1_s3_1_1_s3_client.html](https://docs.aws.amazon.com/sdk-for-cpp/latest/api/aws-cpp-sdk-s3/html/class_aws_1_1_s3_1_1_s3_client.html) 

  La biblioteca `S3Client` es una interfaz de Amazon S3 con todas las características.

  El `list_buckets_disabling_dns_cache.cpp` ejemplo de este conjunto está diseñado específicamente para funcionar con CURL Linux/Mac (aunque se puede modificar para que funcione en Windows). Si está en Windows, elimine el archivo `list_buckets_disabling_dns_cache.cpp` antes de compilar el proyecto, ya que se basa en el curl HttpClient de Linux.

  El código de ejemplo que utiliza `S3Client` está en la [carpeta `s3`](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code/s3) de GitHub. Consulte el archivo [Readme](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code/s3/README.md) en GitHub para ver una lista completa de las funciones que se muestran en este ejemplo.

  Algunas partes de los ejemplos de `s3` se tratan con más detalle en esta guía:
  + [Creación, listado y eliminación de buckets](examples-s3-buckets.md)
  + [Operaciones en objetos](examples-s3-objects.md): carga y descarga de objetos de datos
  + [Administración de permisos de acceso de Amazon S3](examples-s3-access-permissions.md)
  + [Administración del acceso a los buckets de Amazon S3 mediante políticas de buckets](examples-s3-bucket-policies.md)
  + [Configuración de un bucket de Amazon S3 como un sitio web](examples-s3-website-configuration.md)
+ Clase [https://docs.aws.amazon.com/sdk-for-cpp/latest/api/aws-cpp-sdk-s3-crt/html/class_aws_1_1_s3_crt_1_1_s3_crt_client.html](https://docs.aws.amazon.com/sdk-for-cpp/latest/api/aws-cpp-sdk-s3-crt/html/class_aws_1_1_s3_crt_1_1_s3_crt_client.html) 

  `S3CrtClient` se ha agregado en la versión 1.9 del SDK. `S3CrtClient` proporciona un rendimiento alto para las operaciones GET (descarga) y PUT (carga) de Amazon S3. `S3CrtClient`Se implementa en la parte superior de las bibliotecas de AWS Common Runtime (CRT). 

  El código de ejemplo que utiliza `S3CrtClient` está en la [carpeta `s3-crt`](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code/s3-crt) de GitHub. Consulte el archivo [Readme](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code/s3-crt/README.md) en GitHub para ver una lista completa de las funciones que se muestran en este ejemplo.
  + [Uso de `S3CrtClient` para operaciones de Amazon S3](examples-s3-crt.md)
+ Clase [https://docs.aws.amazon.com/sdk-for-cpp/latest/api/aws-cpp-sdk-transfer/html/class_aws_1_1_transfer_1_1_transfer_manager.html](https://docs.aws.amazon.com/sdk-for-cpp/latest/api/aws-cpp-sdk-transfer/html/class_aws_1_1_transfer_1_1_transfer_manager.html) 

  `TransferManager` es un servicio totalmente administrado que permite transferir archivos a través del Protocolo de File Transfer (FTP), el Protocolo de File Transfer a través de SSL (FTPS) o el Protocolo de File Transfer (SFTP) de Secure Shell (SSH) directamente hacia o desde Amazon S3.

  El código de ejemplo que utiliza `TransferManager` está en la [carpeta `transfer-manager`](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code/transfer-manager) de GitHub. Consulte el archivo [Readme](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code/transfer-manager/README.md) en GitHub para ver una lista completa de las funciones que se muestran en este ejemplo.
  + [Uso TransferManager para operaciones de Amazon S3](examples-s3-transfermanager.md)

# Creación, listado y eliminación de buckets
<a name="examples-s3-buckets"></a>

Todos los *objetos* o archivos de Amazon Simple Storage Service (Amazon S3) están contenidos en un *bucket*, que representa una carpeta de objetos. Cada bucket tiene un nombre único a nivel mundial dentro de AWS. Para obtener más información, consulte [Uso de buckets de Amazon S3](https://docs.aws.amazon.com/AmazonS3/latest/dev/UsingBucket.html) en la Guía del usuario de Amazon Simple Storage Service.

## Requisitos previos
<a name="codeExamplePrereq"></a>

Antes de comenzar, le recomendamos que lea [Primeros pasos con el AWS SDK para C\$1\$1](getting-started.md). 

Descargue el código de ejemplo y compile la solución tal y como se describe en [Introducción a los ejemplos de código](getting-started-code-examples.md). 

Para ejecutar los ejemplos, el perfil de usuario que su código utilice para realizar las solicitudes debe tener los permisos adecuados en AWS (para el servicio y la acción). Para obtener más información, consulte [Proporcionar credenciales de AWS](credentials.md).

## Obtener una lista de buckets
<a name="list-buckets"></a>

Para ejecutar el ejemplo `list_buckets`, en el símbolo del sistema, vaya hasta la carpeta en la que el sistema de compilación crea los ejecutables de compilación. Ejecute el ejecutable con un nombre similar a `run_list_buckets` (el nombre completo del archivo ejecutable variará en función de su sistema operativo). El resultado muestra una lista de los buckets de su cuenta, si tiene alguno, o una lista vacía si no tienes ningún bucket.

En `list_buckets.cpp`, hay dos métodos:
+ `main()` llama a `ListBuckets()`. 
+ `ListBuckets()` usa el SDK para consultar sus depósitos.

El objeto `S3Client` llama al método `ListBuckets()` del SDK. Si se ejecuta correctamente, el método devuelve un objeto `ListBucketOutcome`, que contiene un objeto `ListBucketResult`. El objeto `ListBucketResult` llama al método `GetBuckets()` para obtener una lista de objetos `Bucket` que contienen información sobre cada bucket de Amazon S3 de su cuenta.

 **Código de** 

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

Consulte el [ejemplo de list\$1buckets](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code/s3/list_buckets.cpp) completo en Github.

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



Para ejecutar el ejemplo `create_bucket`, en el símbolo del sistema, vaya hasta la carpeta en la que el sistema de compilación crea los ejecutables de compilación. Ejecute el ejecutable con un nombre similar a `run_create_bucket` (el nombre completo del archivo ejecutable variará en función de su sistema operativo). El código crea un depósito vacío en su cuenta y, a continuación, muestra si la solicitud se ha realizado correctamente o no.

En `create_bucket.cpp`, hay dos métodos: 
+ `main()` llama a `CreateBucket()`. En `main()`, tiene que cambiar Región de AWS por la región de su cuenta con `enum`. Para ver la región de su cuenta, inicie sesión en la [Consola de administración de AWS](https://console.aws.amazon.com/) y localice la región en la esquina superior derecha. 
+ `CreateBucket()` utiliza el SDK para crear un bucket. 



El objeto `S3Client` llama al método `CreateBucket()` del SDK, transfiriéndole un objeto `CreateBucketRequest` con el nombre del bucket. De forma predeterminada, los buckets se crean en la región *us-east-1* (Norte de Virginia). Si su región no es *us-east-1*, el código establece una restricción de bucket para garantizar que el bucket se cree en su región.

 **Código de** 

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

Consulte el [ejemplo de create\$1buckets](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code/s3/create_bucket.cpp) completo en Github.

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



Para ejecutar el ejemplo `delete_bucket`, en el símbolo del sistema, vaya hasta la carpeta en la que el sistema de compilación crea los ejecutables de compilación. Ejecute el ejecutable con un nombre similar a `run_delete_bucket` (el nombre completo del archivo ejecutable variará en función de su sistema operativo). El código elimina el bucket especificado de su cuenta y, a continuación, muestra si la solicitud se ha realizado correctamente o no.

En `delete_bucket.cpp`, hay dos métodos. 
+ `main()` llama a `DeleteBucket()`. En `main()`, tiene que cambiar Región de AWS por la región de su cuenta con `enum`. También debe cambiar `bucket_name` por el nombre del bucket que desea eliminar. 
+ `DeleteBucket()` usa el SDK para eliminar el bucket. 



El objeto `S3Client` usa el método `DeleteBucket()` del SDK, transfiriéndole un objeto `DeleteBucketRequest` con el nombre del bucket que se va a eliminar. El bucket debe estar vacío para que funcione correctamente.

 **Código**

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

Consulte el [ejemplo de delete\$1bucket](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code/s3/delete_bucket.cpp) completo en Github.

# Operaciones en objetos
<a name="examples-s3-objects"></a>

Un objeto de Amazon S3 representa un *archivo* o un conjunto de datos. Cada objeto debe residir en un [bucket](examples-s3-buckets.md).

## Requisitos previos
<a name="codeExamplePrereq"></a>

Antes de comenzar, le recomendamos que lea [Primeros pasos con el AWS SDK para C\$1\$1](getting-started.md). 

Descargue el código de ejemplo y compile la solución tal y como se describe en [Introducción a los ejemplos de código](getting-started-code-examples.md). 

Para ejecutar los ejemplos, el perfil de usuario que utilice su código para realizar las solicitudes debe tener los permisos adecuados AWS (para el servicio y la acción). Para obtener más información, consulte [Proporcionar AWS credenciales](credentials.md).

## Para cargar un archivo en un bucket
<a name="upload-object"></a>

Utilice la función `PutObject` del objeto `S3Client` y proporcione un nombre de bucket, un nombre de clave y el archivo que se va a cargar. `Aws::FStream` se utiliza para cargar el contenido del archivo local en el bucket. El bucket debe existir o se producirá un error.

Para ver un ejemplo sobre cómo cargar objetos de forma asíncrona, consulte [Programación asíncrona mediante AWS SDK para C\$1\$1](async-methods.md).

 **Código** 

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

Consulte el [ejemplo completo](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code/s3/put_object.cpp) en GitHub.

## Carga de una cadena en un bucket
<a name="upload-object-string"></a>

Utilice la función `PutObject` del objeto `S3Client` y proporcione un nombre de bucket, un nombre de clave y el archivo que se va a cargar. El bucket debe existir o se producirá un error. Este ejemplo se diferencia del anterior porque se utiliza `Aws::StringStream` para cargar un objeto de datos de cadena en memoria directamente en un bucket.

Para ver un ejemplo sobre cómo cargar objetos de forma asíncrona, consulte [Programación asíncrona mediante AWS SDK para C\$1\$1](async-methods.md).

 **Código** 

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

Consulte el [ejemplo completo](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code/s3/put_object_buffer.cpp) en GitHub.

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

Para obtener una lista de objetos dentro de un bucket, utilice la función `ListObjects` del objeto `S3Client`. Proporcione una solicitud `ListObjectsRequest` configurada con el nombre de un bucket para enumerar su contenido.

La función `ListObjects` devuelve un objeto `ListObjectsOutcome` que puede utilizar para obtener una lista de objetos en forma de instancias de `Object`.

 **Código** 

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

Consulte el [ejemplo completo](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code/s3/list_objects.cpp) en GitHub.

## Descargar un objeto
<a name="download-object"></a>

Utilice la función `GetObject` del objeto `S3Client`, transfiriéndole una solicitud `GetObjectRequest` que debe configurar con el nombre de un bucket y la clave del objeto para descargar. `GetObject` devuelve un objeto [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) que consta de un objeto [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) y un [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` se puede usar para acceder a los datos del objeto S3.

En el siguiente ejemplo se descarga un objeto de Amazon S3. El contenido del objeto se almacena en una variable local y la primera línea del contenido se envía a la consola.

 **Código** 

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

Consulte el [ejemplo completo](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code/s3/get_object.cpp) en GitHub.

## Elimine un objeto
<a name="delete-object"></a>

Utilice la función `DeleteObject` del objeto `S3Client`, transfiriéndole una solicitud `DeleteObjectRequest` que debe configurar con el nombre de un bucket y el objeto para descargar. *El bucket y la clave de objeto especificados deben existir o se producirá un error*.

 **Código** 

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

Consulte el [ejemplo completo](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code/s3/delete_object.cpp) en GitHub.

# Administración de permisos de acceso de Amazon S3
<a name="examples-s3-access-permissions"></a>

Los permisos de acceso para un bucket o un objeto de Amazon S3 se definen en una lista de control de acceso (ACL). La ACL especifica el propietario de las concesiones bucket/object y una lista de las mismas. Cada concesión especifica un usuario (o beneficiario) y los permisos del usuario para acceder al bucket o al objeto; por ejemplo, acceso de lectura (READ) o escritura (WRITE).

## Requisitos previos
<a name="codeExamplePrereq"></a>

Antes de comenzar, le recomendamos que lea [Primeros pasos con el AWS SDK para C\$1\$1](getting-started.md). 

Descargue el código de ejemplo y compile la solución tal y como se describe en [Introducción a los ejemplos de código](getting-started-code-examples.md). 

Para ejecutar los ejemplos, el perfil de usuario que utilice su código para realizar las solicitudes debe tener los permisos adecuados AWS (para el servicio y la acción). Para obtener más información, consulte [Proporcionar AWS credenciales](credentials.md).

## Administración de la lista de control de acceso de un objeto
<a name="manage-an-object-s-access-control-list"></a>

La lista de control de acceso de un objeto se puede recuperar llamando al método`GetObjectAcl` de `S3Client`. El método acepta los nombres del objeto y su bucket. El valor devuelto incluye el `Owner` de las ACL y una lista de `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";
    }
}
```

La ACL se puede modificar creando una nueva o cambiando las concesiones especificadas en la actual. La ACL actualizada se convierte en la nueva ACL actual al transferirla al método `PutObjectAcl`.

El siguiente código usa la ACL recuperada por `GetObjectAcl` y le agrega una nueva concesión. El usuario o beneficiario recibe el permiso READ para el objeto. La ACL modificada se pasa a `PutObjectAcl` y, de este modo, se convierte en la nueva ACL actual. 

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

Consulte el [ejemplo completo](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code/s3/get_put_object_acl.cpp) en GitHub.

## Administración de la lista de control de acceso de un bucket
<a name="manage-a-bucket-s-access-control-list"></a>

En la mayoría de los casos, el método preferido para configurar los permisos de acceso de un bucket es definir una política de bucket. Sin embargo, los buckets también admiten listas de control de acceso para los usuarios que deseen utilizarlas.

La administración de una lista de control de acceso para un bucket es idéntica a la que se usa para un objeto. El método `GetBucketAcl` recupera la ACL actual de un bucket y `PutBucketAcl` aplica una nueva ACL al bucket.

El siguiente código muestra cómo obtener y configurar la ACL de un bucket.

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

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

    return result;
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    return outcome.IsSuccess();
}

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

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

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

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

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

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

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

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

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

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

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

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

    return outcome.IsSuccess();
}

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

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

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

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

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

Consulte el [ejemplo completo](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code/s3/get_put_bucket_acl.cpp) en GitHub.

# Administración del acceso a los buckets de Amazon S3 mediante políticas de buckets
<a name="examples-s3-bucket-policies"></a>

Puede definir, obtener o eliminar una *política de bucket* para administrar el acceso a sus buckets de Amazon S3.

## Requisitos previos
<a name="codeExamplePrereq"></a>

Antes de comenzar, le recomendamos que lea [Primeros pasos con el AWS SDK para C\$1\$1](getting-started.md). 

Descargue el código de ejemplo y compile la solución tal y como se describe en [Introducción a los ejemplos de código](getting-started-code-examples.md). 

Para ejecutar los ejemplos, el perfil de usuario que utiliza tu código para realizar las solicitudes debe tener los permisos adecuados AWS (para el servicio y la acción). Para obtener más información, consulte [Proporcionar AWS credenciales](credentials.md).

## Definir una política de bucket
<a name="set-s3-bucket-policy"></a>

Puede establecer la política de bucket para un bucket de S3 concreto llamando a la `PutBucketPolicy` función `S3Client`'s y proporcionándole el nombre del bucket y la representación en JSON de la política en un [PutBucketPolicyRequest](https://docs.aws.amazon.com/sdk-for-cpp/latest/api/aws-cpp-sdk-s3/html/class_aws_1_1_s3_1_1_model_1_1_put_bucket_policy_request.html).

 **Código** 

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

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

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

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

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

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

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

    return outcome.IsSuccess();
}
```

**nota**  
La clase de [utilidad Aws: :Utils: :Json: JsonValue](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) puede usarse para ayudarle a construir objetos JSON válidos a los que pasar. `PutBucketPolicy`

Consulte el [ejemplo completo](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code/s3/put_bucket_policy.cpp) en GitHub.

## Obtener una política de bucket
<a name="get-s3-bucket-policy"></a>

Para recuperar la política de un bucket de Amazon S3, llama a la `GetBucketPolicy` función `S3Client`'s y pásale el nombre del bucket en un [GetBucketPolicyRequest](https://docs.aws.amazon.com/sdk-for-cpp/latest/api/aws-cpp-sdk-s3/html/class_aws_1_1_s3_1_1_model_1_1_get_bucket_policy_request.html).

 **Código** 

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

Consulte el [ejemplo completo](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code/s3/get_bucket_policy.cpp) en GitHub.

## Eliminar una política de bucket
<a name="delete-s3-bucket-policy"></a>

Para eliminar una política de bucket, llama a la `DeleteBucketPolicy` función `S3Client`'s y proporciona el nombre del bucket en un [DeleteBucketPolicyRequest](https://docs.aws.amazon.com/sdk-for-cpp/latest/api/aws-cpp-sdk-s3/html/class_aws_1_1_s3_1_1_model_1_1_delete_bucket_policy_request.html).

 **Código** 

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

Este función se ejecuta correctamente aunque el bucket no tenga una política todavía. Si especifica el nombre de un bucket que no existe o si no tiene acceso al bucket, se produce la excepción `AmazonServiceException`.

Consulte el [ejemplo completo](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code/s3/delete_bucket_policy.cpp) en GitHub.

## Más información
<a name="more-info"></a>
+  [PutBucketPolicy](https://docs.aws.amazon.com/AmazonS3/latest/API/PutBucketPolicy.html)en la referencia de la API de Amazon Simple Storage Service
+  [GetBucketPolicy](https://docs.aws.amazon.com/AmazonS3/latest/API/GetBucketPolicy.html)en la referencia de la API de Amazon Simple Storage Service
+  [DeleteBucketPolicy](https://docs.aws.amazon.com/AmazonS3/latest/API/DeleteBucketPolicy.html)en la referencia de la API de Amazon Simple Storage Service
+  [Información general del lenguaje de la política de acceso](https://docs.aws.amazon.com/AmazonS3/latest/dev/access-policy-language-overview.html) en la Guía del usuario de Amazon Simple Storage Service
+  [Ejemplos de política de bucket](https://docs.aws.amazon.com/AmazonS3/latest/dev/example-bucket-policies.html) en la Guía del usuario de Amazon Simple Storage Service

# Configuración de un bucket de Amazon S3 como un sitio web
<a name="examples-s3-website-configuration"></a>

Puede configurar un bucket de Amazon S3 para que se comporte como un sitio web. Para ello, debe establecer la configuración de su sitio web.

## Requisitos previos
<a name="codeExamplePrereq"></a>

Antes de comenzar, le recomendamos que lea [Primeros pasos con el AWS SDK para C\$1\$1](getting-started.md). 

Descargue el código de ejemplo y compile la solución tal y como se describe en [Introducción a los ejemplos de código](getting-started-code-examples.md). 

Para ejecutar los ejemplos, el perfil de usuario que utiliza tu código para realizar las solicitudes debe tener los permisos adecuados AWS (para el servicio y la acción). Para obtener más información, consulte [Proporcionar AWS credenciales](credentials.md).

## Establecimiento de la configuración de sitio web de un bucket
<a name="set-a-bucket-s-website-configuration"></a>

Para establecer la configuración del sitio web de un bucket de Amazon S3, llame a la `PutBucketWebsite` función `S3Client`'s con un [PutBucketWebsiteRequest](https://docs.aws.amazon.com/sdk-for-cpp/latest/api/aws-cpp-sdk-s3/html/class_aws_1_1_s3_1_1_model_1_1_put_bucket_website_request.html)objeto que contenga el nombre del bucket y la configuración de su sitio web, proporcionados en un [WebsiteConfiguration](https://docs.aws.amazon.com/sdk-for-cpp/latest/api/aws-cpp-sdk-s3/html/class_aws_1_1_s3_1_1_model_1_1_website_configuration.html)objeto.

Es *obligatorio* establecer un documento de índice; todos los demás parámetros son opcionales.

 **Código** 

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

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

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

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

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

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

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

    return outcome.IsSuccess();
}
```

**nota**  
El establecimiento de la configuración de sitio web no modifica los permisos de acceso del bucket. Para que los archivos estén visibles en la web, también deberá definir una *política de bucket* que permita el acceso de lectura pública a los archivos del bucket. Para obtener más información, consulte [Administración del acceso a buckets de Amazon S3 mediante políticas de buckets](examples-s3-bucket-policies.md).

Consulte el [ejemplo completo](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code/s3/put_website_config.cpp) en GitHub.

## Obtener la configuración de sitio web de un bucket
<a name="get-a-bucket-s-website-configuration"></a>

Para obtener la configuración del sitio web de un bucket de Amazon S3, llama a la `GetBucketWebsite` función `S3Client`'s y [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)contiene el nombre del bucket para recuperar la configuración.

La configuración se devolverá como un [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)objeto dentro del objeto de resultado. Si no hay ninguna configuración de sitio web para el bucket, se devolverá `null`.

 **Código** 

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

Consulte el [ejemplo completo](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code/s3/get_website_config.cpp) en GitHub.

## Eliminar la configuración de sitio web de un bucket
<a name="delete-a-bucket-s-website-configuration"></a>

Para eliminar la configuración del sitio web de un bucket de Amazon S3, llama a la `DeleteBucketWebsite` función `S3Client`'s con un [DeleteBucketWebsiteRequest](https://docs.aws.amazon.com/sdk-for-cpp/latest/api/aws-cpp-sdk-s3/html/class_aws_1_1_s3_1_1_model_1_1_delete_bucket_website_request.html): que contenga el nombre del bucket del que se va a eliminar la configuración.

 **Código** 

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

Consulte el [ejemplo completo](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code/s3/delete_website_config.cpp) en GitHub.

## Más información
<a name="more-information"></a>
+  [PUT Bucket website](https://docs.aws.amazon.com/AmazonS3/latest/API/RESTBucketPUTwebsite.html) en la Referencia de la API de Amazon Simple Storage Service
+  [GET Bucket website](https://docs.aws.amazon.com/AmazonS3/latest/API/RESTBucketGETwebsite.html) en la Referencia de la API de Amazon Simple Storage Service
+  [DELETE Bucket website](https://docs.aws.amazon.com/AmazonS3/latest/API/RESTBucketDELETEwebsite.html) en la Referencia de la API de Amazon Simple Storage Service

# Uso TransferManager para operaciones de Amazon S3
<a name="examples-s3-transfermanager"></a>

Puede utilizar la AWS SDK para C\$1\$1 `TransferManager` clase para transferir archivos de forma fiable desde el entorno local a Amazon S3 y para copiar objetos de una ubicación de Amazon S3 a otra. `TransferManager`puede ver el progreso de una transferencia y pausar o reanudar las cargas y descargas.

**nota**  
Para evitar que te cobren por cargas incompletas o parciales, te recomendamos que habilites la regla de [AbortIncompleteMultipartUpload](https://docs.aws.amazon.com/AmazonS3/latest/userguide/mpu-abort-incomplete-mpu-lifecycle-config.html)ciclo de vida en tus buckets de Amazon S3.  
Esta regla le indica a Amazon S3 que anule las cargas multiparte que no se completen en un número especificado de días después de iniciarse. Cuando se supera el plazo establecido, Amazon S3 anula la carga y, a continuación, elimina los datos de la carga incompleta.   
Para obtener más información, consulte [Configuración del ciclo de vida de un bucket](https://docs.aws.amazon.com/AmazonS3/latest/userguide/how-to-set-lifecycle-configuration-intro.html) en la Guía del usuario de Amazon S3.

## Requisitos previos
<a name="codeExamplePrereq"></a>

Antes de comenzar, le recomendamos que lea [Primeros pasos con el AWS SDK para C\$1\$1](getting-started.md). 

Descargue el código de ejemplo y compile la solución tal y como se describe en [Introducción a los ejemplos de código](getting-started-code-examples.md). 

Para ejecutar los ejemplos, el perfil de usuario que utilice tu código para realizar las solicitudes debe tener los permisos adecuados AWS (para el servicio y la acción). Para obtener más información, consulte [Proporcionar AWS credenciales](credentials.md).

## Carga y descarga de un objeto mediante `TransferManager`
<a name="stream"></a>

En este ejemplo, se muestra cómo [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) transfiere un objeto grande en la memoria. Se llama a los métodos `UploadFile` y `DownloadFile` de forma asíncrona que devuelven un `TransferHandle` para gestionar el estado de la solicitud. Si el objeto cargado es superior al `bufferSize`, se realiza una carga multiparte. El valor predeterminado del `bufferSize` es de 5 MB, pero se puede configurar mediante [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;
```

Consulte el [ejemplo completo](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code/transfer-manager/transferOnStream.cpp) en GitHub.

# Uso de `S3CrtClient` para operaciones de Amazon S3
<a name="examples-s3-crt"></a>

La `S3CrtClient` clase está disponible en la versión 1.9 de AWS SDK para C\$1\$1 y mejora el rendimiento de la carga y descarga de archivos de datos de gran tamaño desde y hacia Amazon S3. Para obtener más información sobre las mejoras de esta versión, consulte [Mejorar el rendimiento de Amazon S3 con AWS SDK para C\$1\$1](https://github.com/aws/aws-sdk-cpp/wiki/Improving-S3-Throughput-with-AWS-SDK-for-CPP-v1.9) la versión 1.9

El `S3CrtClient` se implementa sobre las [bibliotecas Common Runtime (CRT) de AWS](https://docs.aws.amazon.com/sdkref/latest/guide/common-runtime.html).

**nota**  
Para evitar que te cobren por cargas incompletas o parciales, te recomendamos que habilites la regla de [AbortIncompleteMultipartUpload](https://docs.aws.amazon.com/AmazonS3/latest/userguide/mpu-abort-incomplete-mpu-lifecycle-config.html)ciclo de vida en tus buckets de Amazon S3.  
Esta regla le indica a Amazon S3 que anule las cargas multiparte que no se completen en un número especificado de días después de iniciarse. Cuando se supera el plazo establecido, Amazon S3 anula la carga y, a continuación, elimina los datos de la carga incompleta.   
Para obtener más información, consulte [Configuración del ciclo de vida de un bucket](https://docs.aws.amazon.com/AmazonS3/latest/userguide/how-to-set-lifecycle-configuration-intro.html) en la Guía del usuario de Amazon S3.

## Requisitos previos
<a name="codeExamplePrereq"></a>

Antes de comenzar, le recomendamos que lea [Primeros pasos con el AWS SDK para C\$1\$1](getting-started.md). 

Descargue el código de ejemplo y compile la solución tal y como se describe en [Introducción a los ejemplos de código](getting-started-code-examples.md). 

Para ejecutar los ejemplos, el perfil de usuario que utilice tu código para realizar las solicitudes debe tener los permisos adecuados AWS (para el servicio y la acción). Para obtener más información, consulte [Proporcionar AWS credenciales](credentials.md).

## Carga y descarga de un objeto mediante `S3CrtClient`
<a name="stream"></a>

En este ejemplo se muestra cómo usar [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). En el ejemplo se crea un bucket, se carga un objeto, se descarga el objeto y, a continuación, se eliminan el archivo y el bucket. Una operación PUT se convierte en una carga multiparte. Una operación GET se convierte en varias solicitudes GET "ordenadas". Para obtener más información sobre cargas multiparte, consulte [Carga y copia de objetos con carga multiparte](https://docs.aws.amazon.com/AmazonS3/latest/userguide/mpuoverview.html) en la Guía del usuario de Amazon S3. 

En este ejemplo, el archivo de datos proporcionado, `ny.json`, se carga como una carga multiparte. Puede confirmarlo consultando los registros de depuración después de ejecutar correctamente el programa.

Si se produce un error en la carga, `AbortMultipartUpload` se emite en una en la biblioteca CRT subyacente para limpiar las partes ya cargadas. Sin embargo, no todos los fallos se pueden solucionar internamente (por ejemplo, si se desconecta un cable de red). Le recomendamos crear una regla de ciclo de vida en su bucket de Amazon S3 para garantizar que los datos cargados parcialmente no permanezcan en su cuenta (los datos cargados parcialmente siguen siendo facturables). Para obtener información sobre cómo configurar una regla de ciclo de vida, consulte [Descubrimiento y eliminación de cargas multiparte incompletas para reducir los costos de Amazon S3](https://aws.amazon.com/blogs/aws-cost-management/discovering-and-deleting-incomplete-multipart-uploads-to-lower-amazon-s3-costs/ ) 

**Uso del registro de depuración para explorar los detalles de las cargas multiparte**

1. En `main()`, tenga en cuenta que hay comentarios "TODO" con instrucciones para actualizar el código.

   1. Para `file_name`: desde el enlace proporcionado en el comentario del código, descargue un archivo de datos de muestra `ny.json` o utilice un archivo de datos de gran tamaño que sea suyo.

   1. Para`region`: Actualice la `region` variable, mediante la enumeración, a la Región de AWS de su cuenta. Para encontrar la región de su cuenta, inicie sesión en la Consola de administración de AWS y localice la región en la esquina superior derecha.

1. Compile el ejemplo.

1. Copie el archivo especificado en la variable `file_name` en su carpeta de ejecutables y ejecute el archivo ejecutable `s3-crt-demo`.

1. En la carpeta de ejecutables, busque el archivo `.log` más reciente.

1. Abra el archivo de registro, seleccione **buscar** y escriba **partNumber**.

1. El registro contiene entradas similares a las siguientes, donde se especifican `uploadId` y `partNumber` para cada parte del archivo cargado:

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

    and 

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

Consulte el [ejemplo completo](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code/s3-crt/s3-crt-demo.cpp) en GitHub.