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.

# Obtención AWS SDK para C\$1\$1 del código fuente
<a name="sdk-from-source"></a>

Puedes usar el código AWS SDK para C\$1\$1 desde tu código compilando primero el SDK desde el código fuente y luego instalándolo localmente. 


**Información general del proceso**  

| Proceso general  | Detalles del proceso | 
| --- | --- | 
|  [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/sdk-for-cpp/v1/developer-guide/sdk-from-source.html) |  Primero compile el SDK desde el código fuente e instálelo.  [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/sdk-for-cpp/v1/developer-guide/sdk-from-source.html) | 
|  [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/sdk-for-cpp/v1/developer-guide/sdk-from-source.html) |  Luego, desarrolle su propia aplicación con el SDK.  [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/sdk-for-cpp/v1/developer-guide/sdk-from-source.html)  | 

# Construyendo el AWS SDK para C\$1\$1 en Windows
<a name="setup-windows"></a>

Para configurarlo AWS SDK para C\$1\$1, puede crear el SDK usted mismo directamente desde la fuente o descargar las bibliotecas mediante un administrador de paquetes.



El código fuente del SDK se divide en paquetes individuales por servicio. La instalación del SDK completo puede tardar hasta una hora. Si se instala solo el subconjunto específico de servicios que utiliza el programa, se reduce el tiempo de instalación y también el tamaño del disco. Para elegir qué servicios instalar, es necesario que conozca el nombre del paquete de cada servicio que utiliza el programa. Puedes ver la lista de directorios de paquetes en [https://github.com/aws/aws-sdk-cpp](https://github.com/aws/aws-sdk-cpp)on GitHub. El nombre del paquete es el sufijo del nombre del directorio del servicio. 

```
aws-sdk-cpp\aws-cpp-sdk-<packageName>   # Repo directory name and packageName
aws-sdk-cpp\aws-cpp-sdk-s3              # Example: Package name is s3
```

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

Necesita un mínimo de 4 GB de RAM para crear algunos de los AWS clientes más grandes. Es posible que el SDK no se pueda compilar en los tipos de instancia *t2.micro*, *t2.small* y otros tipos de instancias pequeñas de Amazon EC2 por falta de memoria.

Para usar el AWS SDK para C\$1\$1, necesita uno de los siguientes:
+ Microsoft Visual Studio 2015 o versiones posteriores 
+  GNU Compiler Collection (GCC) 4.9 o versiones posteriores o
+  Clang 3.3 o versiones posteriores.

## Compilación del SDK para Windows con curl
<a name="build-curl-id"></a>

En Windows, el SDK se crea con [WinHTTP](https://msdn.microsoft.com/en-us/library/windows/desktop/aa382925%28v=vs.85%29.aspx) como cliente HTTP predeterminado. Sin embargo, WinHTTP 1.0 no admite la transmisión bidireccional HTTP/2, que es necesaria para algunos, como Servicios de AWS Amazon Transcribe y Amazon Lex. Por lo tanto, a veces será necesario desarrollar la compatibilidad con curl con el SDK. Para ver todas las opciones de descarga de curl disponibles, consulte [Versiones y descargas de curl](https://curl.se/download.html). A continuación, se muestra un método para compilar el SDK compatible con curl:

**Para compilar el SDK con compatibilidad con la biblioteca curl incluida**

1. Vaya a [curl para Windows](https://curl.se/windows/) y descargue el paquete binario de curl para Microsoft Windows. 

1. Desempaquete el paquete en una carpeta de su equipo; por ejemplo, `C:\curl`. 

1. Vaya a los [certificados de CA extraídos de Mozilla](http://curl.haxx.se/docs/caextract.html) y descargue el archivo `cacert.pem`. Este archivo de Privacy Enhanced Mail (PEM) contiene un paquete de certificados digitales válidos que se utilizan para verificar la autenticidad de los sitios web seguros. Los certificados los distribuyen empresas de entidades emisoras de certificados (CA), como Verisign. GlobalSign 

1. Mueva el archivo `cacert.pem` a la subcarpeta `bin` que ha desempaquetado en un paso anterior; por ejemplo, `C:\curl\bin`. Cambie el nombre del archivo a `curl-ca-bundle.crt` 

Además, Microsoft Build Engine (MSBuild) debe poder localizar el rizo `dll` en el procedimiento siguiente. Por lo tanto, debe agregar la ruta de la carpeta del `bin` de curl a la variable de entorno `PATH` de Windows; por ejemplo, `set PATH=%PATH%;C:\curl\bin`. Debe agregarla cada vez que abra una nueva línea de comandos para compilar el SDK. O también, puede establecer la variable de entorno de forma global en la configuración del sistema de Windows para recordar la configuración.

Al *compilar el SDK desde el código fuente* en el procedimiento que sigue a continuación, consulte el paso 5 (Generar archivos de compilación) para conocer la sintaxis de comandos necesaria para incorporar curl a su SDK. 

Al escribir el código, debe establecer la ubicación del archivo de certificado como `caFile` en [Configuración de clientes de servicio en código de AWS SDK para C\$1\$1](client-config.md). Para ver un ejemplo del uso de Amazon Transcribe, consulte [https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code/transcribe-streaming](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code/transcribe-streaming)en el *repositorio de ejemplos AWS de código* en. GitHub

## Compilación del SDK desde el código fuente
<a name="setup-windows-from-source"></a>

Utilice las herramientas de línea de comandos para compilar el SDK desde el código fuente. Puede personalizar la compilación del SDK con este método. Para obtener información sobre las opciones disponibles, consulte [CMake Parámetros](cmake-params.md). Estos son los tres pasos principales: En primer lugar, se crean los archivos utilizando CMake. En segundo lugar, se utilizan MSBuild para crear los binarios del SDK que funcionan con el sistema operativo y para crear la cadena de herramientas. En tercer lugar, instale o copie los binarios en la ubicación correcta del equipo donde se está realizando el desarrollo.

**Para compilar el SDK desde el código fuente**

1. Instala [CMake](https://cmake.org/)(versión 3.13 como mínimo) y las herramientas de compilación pertinentes para tu plataforma. Le recomendamos añadir `cmake` al `PATH`. Para comprobar tu versión de CMake, abre una línea de comandos y ejecuta el comando **cmake --version**

1. Cuando se lo indique el sistema, abra la carpeta en la que desee almacenar el SDK.

1. Obtenga el código fuente más reciente.

   La versión 1.11 utiliza submódulos de git para empaquetar las dependencias externas. Esto incluye las [bibliotecas CRT](https://docs.aws.amazon.com/sdkref/latest/guide/common-runtime.html) descritas en la *Guía de referencia de herramientas AWS SDKs y herramientas*.

   Descarga o clona la fuente del SDK desde [https://github.com/aws/aws-sdk-cpp](https://github.com/aws/aws-sdk-cpp): GitHub
   + Clonación con Git: HTTPS

     ```
     git clone --recurse-submodules https://github.com/aws/aws-sdk-cpp
     ```
   + Clonación con Git: SSH

     ```
     git clone --recurse-submodules git@github.com:aws/aws-sdk-cpp.git
     ```

1. Le recomendamos que guarde los archivos de compilación generados fuera del directorio de origen del SDK. Cree un nuevo directorio para almacenar los archivos de compilación y vaya hasta esa carpeta.

   ```
   mkdir sdk_build
   cd sdk_build
   ```

1. Ejecute `cmake` para generar los archivos de compilación. Especifique en la línea de comandos de `cmake` si desea crear una versión *Debug* o una *Release*. Elija `Debug` a lo largo de todo este procedimiento para ejecutar una configuración de depuración del código de la aplicación. Elija `Release` a lo largo de todo este procedimiento para ejecutar una configuración de lanzamiento del código de la aplicación. En Windows, la ubicación de instalación del SDK suele ser `\Program Files (x86)\aws-cpp-sdk-all\`. Sintaxis de comandos: 

   `{path to cmake if not in PATH} {path to source location of aws-sdk-cpp} -DCMAKE_BUILD_TYPE=[Debug | Release] -DCMAKE_PREFIX_PATH={path to install destination}`

   Para ver más formas de modificar el resultado de la compilación, consulta [CMakeParámetros](cmake-params.md).

   Para generar los archivos de compilación, lleve a cabo una de las siguientes acciones:
   + **Generar archivos de compilación (todos Servicios de AWS)**: para compilar el SDK completo, ejecuta cmake y especifica si quieres compilar una versión de *depuración* o una versión de *lanzamiento*. Por ejemplo:

     ```
     cmake "..\aws-sdk-cpp" -DCMAKE_BUILD_TYPE=Debug -DCMAKE_PREFIX_PATH="C:\Program Files (x86)\aws-cpp-sdk-all"
     ```

     
   + **Generar archivos de compilación (subconjunto Servicios de AWS)**: para crear solo un servicio o paquetes de servicios específicos para el SDK, agrega el CMake [BUILD\$1ONLY](cmake-params.md#cmake-build-only) parámetro con los nombres de los servicios separados por punto y coma. El siguiente ejemplo compila únicamente el paquete de servicios Amazon S3:

     ```
     cmake ..\aws-sdk-cpp -DCMAKE_BUILD_TYPE=Debug -DBUILD_ONLY="s3" -DCMAKE_PREFIX_PATH="C:\Program Files (x86)\aws-cpp-sdk-all"
     ```
   + **Genere archivos de compilación (con curl)**: después de completar los requisitos previos de curl, necesita tres opciones adicionales de línea de comandos de cmake para incluir la compatibilidad con curl en el SDK: [FORCE\$1CURL](cmake-params.md#cmake-force-curl), [CURL\$1INCLUDE\$1DIR](cmake-params.md#cmake-curl-include-dir) y [CURL\$1LIBRARY](cmake-params.md#cmake-curl-library). Por ejemplo: 

     ```
     cmake ..\aws-sdk-cpp -DCMAKE_BUILD_TYPE=Debug -DFORCE_CURL=ON -DCURL_INCLUDE_DIR='C:/curl/include'
           -DCURL_LIBRARY='C:/curl/lib/libcurl.dll.a' -DCMAKE_PREFIX_PATH="C:\Program Files (x86)\aws-cpp-sdk-all"
     ```
**nota**  
Si recibes el mensaje de error No se pudieron crear bibliotecas de terceros, ejecuta tu versión de CMake . **cmake --version** Debe utilizar CMake como mínimo la versión 3.13. 

1. Compile los binarios del SDK. Si va a compilar todo el SDK, este paso puede tardar una hora o más. Sintaxis de comandos: 

   `{path to cmake if not in PATH} --build . --config=[Debug | Release]`

   ```
   cmake --build . --config=Debug
   ```
**nota**  
Si recibe el mensaje de error The code execution cannot proceed… dll not found. Reinstalling the program may fix this problem., pruebe a ejecutar el comando `cmake` de nuevo.

1. Abra una línea de comandos con privilegios de **administrador** para instalar el SDK en la ubicación especificada anteriormente mediante el parámetro`CMAKE_PREFIX_PATH`. Sintaxis de comandos: 

   `{path to cmake if not in PATH} --install . --config=[Debug | Release]`

   ```
   cmake --install . --config=Debug
   ```

## Compilación para Android en Windows
<a name="building-for-android"></a>

Para compilar para Android, añada `-DTARGET_ARCH=ANDROID` a su línea de comandos de `cmake`. AWS SDK para C\$1\$1 Incluye un archivo de CMake cadena de herramientas que incluye lo que necesita haciendo referencia a las variables de entorno adecuadas (). `ANDROID_NDK`

Para compilar el SDK para Android en Windows, debe ejecutar `cmake` desde la línea de comandos para desarrolladores de Visual Studio (2015 o versiones posteriores). También necesitará tener NMAKE [NMAKE](https://docs.microsoft.com/en-us/cpp/build/reference/nmake-reference?view=msvc-160) instalado y los comandos **`git`** y **`patch`** en su ruta. Si ha instalado git en un sistema Windows, lo más probable es que encuentre **`patch`** en un directorio secundario (`.../Git/usr/bin/`). Una vez que haya verificado estos requisitos, su línea de comandos de `cmake` cambiará ligeramente para usar NMAKE.

```
cmake -G "NMake Makefiles" `-DTARGET_ARCH=ANDROID` <other options> ..
```

NMAKE compila en serie. Para compilar más rápidamente, le recomendamos que instale JOM como alternativa a NMAKE y que cambie, a continuación, la invocación de `cmake` de la siguiente manera:

```
cmake -G "NMake Makefiles JOM" `-DTARGET_ARCH=ANDROID` <other options> ..
```

Para ver un ejemplo de aplicación, consulta Cómo [configurar una aplicación de Android con AWS SDK para C\$1\$1](https://aws.amazon.com/blogs/developer/setting-up-an-android-application-with-aws-sdk-for-c/)

# Construyendo el AWS SDK para C\$1\$1 en Linux/macOS
<a name="setup-linux"></a>

Para configurarlo AWS SDK para C\$1\$1, puedes crear el SDK tú mismo directamente desde la fuente o descargar las bibliotecas mediante un administrador de paquetes.



El código fuente del SDK se divide en paquetes individuales por servicio. La instalación del SDK completo puede tardar hasta una hora. Si se instala solo el subconjunto específico de servicios que utiliza el programa, se reduce el tiempo de instalación y también el tamaño del disco. Para elegir qué servicios instalar, es necesario que conozca el nombre del paquete de cada servicio que utiliza el programa. Puedes ver la lista de directorios de paquetes en [https://github.com/aws/aws-sdk-cpp](https://github.com/aws/aws-sdk-cpp)on GitHub. El nombre del paquete es el sufijo del nombre del directorio del servicio. 

```
aws-sdk-cpp\aws-cpp-sdk-<packageName>   # Repo directory name and packageName
aws-sdk-cpp\aws-cpp-sdk-s3              # Example: Package name is s3
```

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

Necesita un mínimo de 4 GB de RAM para crear algunos de los AWS clientes más grandes. Es posible que el SDK no se pueda compilar en los tipos de instancia *t2.micro*, *t2.small* y otros tipos de instancias pequeñas de Amazon EC2 por falta de memoria.

Para usar el AWS SDK para C\$1\$1, necesita uno de los siguientes:
+  GNU Compiler Collection (GCC) 4.9 o versiones posteriores o
+  Clang 3.3 o versiones posteriores.

## Requisitos adicionales para los sistemas de Linux
<a name="additional-requirements-for-linux-systems"></a>

También tiene que tener los archivos de encabezado (paquetes `-dev`) para `libcurl`, `libopenssl`, `libuuid`, `zlib` y, de manera opcional, `libpulse` para la compatibilidad con Amazon Polly. Puede encontrar los paquetes con el administrador de paquetes del sistema.

**Para instalar los paquetes en *sistemas basados en Debian/Ubuntu***
+ 

  ```
  sudo apt-get install libcurl4-openssl-dev libssl-dev uuid-dev zlib1g-dev libpulse-dev
  ```

**Para instalar los paquetes en *sistemas Linux/Redhat/Fedora/CentOS basados en Amazon***
+ 

  ```
  sudo yum install libcurl-devel openssl-devel libuuid-devel pulseaudio-libs-devel
  ```

## Compilación del SDK desde el código fuente
<a name="setup-linux-from-source"></a>

Utilice las herramientas de la línea de comandos para compilar el SDK desde el código fuente como alternativa al uso de vcpkg. Puede personalizar la compilación del SDK con este método. Para obtener información sobre las opciones disponibles, consulte [CMake Parámetros](cmake-params.md).

**Para compilar el SDK desde el código fuente**

1. Instale [CMake](https://cmake.org/)(versión 3.13 como mínimo) y las herramientas de compilación pertinentes para su plataforma. Le recomendamos añadir `cmake` al `PATH`. Para comprobar tu versión de CMake, abre una línea de comandos y ejecuta el comando **cmake --version**

1. Cuando se lo indique el sistema, abra la carpeta en la que desee almacenar el SDK.

1. Obtenga el código fuente más reciente.

   La versión 1.11 utiliza submódulos de git para empaquetar las dependencias externas. Esto incluye las [bibliotecas CRT](https://docs.aws.amazon.com/sdkref/latest/guide/common-runtime.html) descritas en la *Guía de referencia de herramientas AWS SDKs y herramientas*.

   Descarga o clona la fuente del SDK desde [https://github.com/aws/aws-sdk-cpp](https://github.com/aws/aws-sdk-cpp): GitHub
   + Clonación con Git: HTTPS

     ```
     git clone --recurse-submodules https://github.com/aws/aws-sdk-cpp
     ```
   + Clonación con Git: SSH

     ```
     git clone --recurse-submodules git@github.com:aws/aws-sdk-cpp.git
     ```

1. Le recomendamos que guarde los archivos de compilación generados fuera del directorio de origen del SDK. Cree un nuevo directorio para almacenar los archivos de compilación y vaya hasta esa carpeta.

   ```
   mkdir sdk_build
   cd sdk_build
   ```

1. Ejecute `cmake` para generar los archivos de compilación. Especifique en la línea de comandos de `cmake` si desea crear una versión *Debug* o una *Release*. Elija `Debug` a lo largo de todo este procedimiento para ejecutar una configuración de depuración del código de la aplicación. Elija `Release` a lo largo de todo este procedimiento para ejecutar una configuración de lanzamiento del código de la aplicación. Sintaxis de comandos: 

   `{path to cmake if not in PATH} {path to source location of aws-sdk-cpp} -DCMAKE_BUILD_TYPE=[Debug | Release] -DCMAKE_PREFIX_PATH={path to install} -DCMAKE_INSTALL_PREFIX={path to install}`

   Para ver más formas de modificar el resultado de la compilación, consulta [CMakeParámetros](cmake-params.md).
**nota**  
Al compilar en un Mac con un sistema de archivos que no distinga entre mayúsculas y minúsculas, compruebe la salida del comando `pwd` en el directorio donde ejecute la compilación. Asegúrese de que la salida `pwd` utilice mayúsculas y minúsculas para los nombres de directorio, como `/Users` y `Documents`.

   Para generar los archivos de compilación, lleve a cabo una de las siguientes acciones:
   + **Generar archivos de compilación (todos Servicios de AWS)**: para compilar el SDK completo, ejecuta cmake y especifica si quieres compilar una versión de *depuración* o una versión de *lanzamiento*. Por ejemplo:

     ```
     cmake ../aws-sdk-cpp -DCMAKE_BUILD_TYPE=Debug -DCMAKE_PREFIX_PATH=/usr/local/ -DCMAKE_INSTALL_PREFIX=/usr/local/
     ```

     
   + **Generar archivos de compilación (subconjunto Servicios de AWS)**: para crear solo un servicio o paquetes de servicios específicos para el SDK, agrega el CMake [BUILD\$1ONLY](cmake-params.md#cmake-build-only) parámetro con los nombres de los servicios separados por punto y coma. El siguiente ejemplo compila únicamente el paquete de servicios Amazon S3:

     ```
     cmake ../aws-sdk-cpp -DCMAKE_BUILD_TYPE=Debug -DCMAKE_PREFIX_PATH=/usr/local/ -DCMAKE_INSTALL_PREFIX=/usr/local/ -DBUILD_ONLY="s3"
     ```
**nota**  
Si recibes el mensaje de error No se pudieron crear bibliotecas de terceros, ejecuta tu versión de CMake . **cmake --version** Debe utilizar CMake como mínimo la versión 3.13. 

1. Compile los binarios del SDK. Si va a compilar todo el SDK, la operación puede tardar una hora o más. 

   ```
   cmake --build . --config=Debug
   ```

1. Instale el SDK. Es posible que tenga que aumentar los privilegios en función de la ubicación en la que decida realizar la instalación.

   ```
   cmake --install . --config=Debug
   ```

## Compilación para Android en Linux
<a name="building-for-android"></a>

Para compilar para Android, añada `-DTARGET_ARCH=ANDROID` a su línea de comandos de `cmake`. AWS SDK para C\$1\$1 Incluye un archivo de CMake cadena de herramientas que incluye lo que necesita haciendo referencia a las variables de entorno adecuadas (). `ANDROID_NDK` Para ver un ejemplo de aplicación, consulta Cómo [configurar una aplicación de Android con AWS SDK para C\$1\$1](https://aws.amazon.com/blogs/developer/setting-up-an-android-application-with-aws-sdk-for-c/)

# Creación de una aplicación sencilla con el AWS SDK para C\$1\$1
<a name="build-cmake"></a>

 [CMake](https://cmake.org/)es una herramienta de compilación que se utiliza para gestionar las dependencias de la aplicación y crear archivos makefiles adecuados para la plataforma en la que se está creando. Puedes utilizarla CMake para crear y construir proyectos con. AWS SDK para C\$1\$1

En este ejemplo, se muestran los buckets de Amazon S3 cuyo propietario es usted. Para este ejemplo, no es necesario que tenga un bucket de Amazon S3 en su cuenta de AWS , pero será mucho más interesante si tiene al menos uno. Consulte [Crear un bucket](https://docs.aws.amazon.com/AmazonS3/latest/userguide/creating-bucket.html) en la *Guía del usuario de Amazon Simple Storage Service* si no tiene uno todavía.

## Paso 1: Escribe el código
<a name="setting-up-a-cmake-project"></a>

Este ejemplo consta de una carpeta que contiene un archivo de código fuente (`hello_s3.cpp`) y un archivo `CMakeLists.txt`. El programa utiliza Amazon S3 para generar informes con la información del bucket de almacenamiento. Este código también está disponible en el [repositorio AWS de ejemplos de código](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code/s3/hello_s3) en GitHub. 

En un archivo de configuración de compilación `CMakeLists.txt`, puede configurar muchas opciones. Para obtener más información, consulte el [CMaketutorial](https://cmake.org/cmake-tutorial/) en el CMake sitio web. 

**nota**  
Deep Dive: configuración de `CMAKE_PREFIX_PATH`  
De forma predeterminada, AWS SDK para C\$1\$1 en macOS, Linux, Android y otras plataformas distintas de Windows se instala en `/usr/local` y en Windows está instalado en`\Program Files (x86)\aws-cpp-sdk-all`.  
Al instalar el AWS SDK en estas ubicaciones estándar, busca CMake automáticamente los recursos necesarios. Sin embargo, si instala el AWS SDK en una ubicación personalizada, debe indicar CMake dónde se encuentran los siguientes recursos derivados de la creación del SDK:  
`AWSSDKConfig.cmake`: un archivo de configuración que indica CMake cómo buscar y usar las bibliotecas del AWS SDK en tu proyecto. Sin este archivo, CMake no puede encontrar los archivos de cabecera del AWS AWS SDK, vincular a las bibliotecas del SDK ni configurar los indicadores de compilación adecuados.
(Para la versión 1.8 y anteriores) La ubicación de las dependencias: `aws-c-event-stream`, `aws-c-common` y `aws-checksums`
Para configurar una ruta de instalación personalizada:  

```
cmake -DCMAKE_PREFIX_PATH=/path/to/your/aws-sdk-installation /path/to/project/you/are/building
```
Si no `CMAKE_PREFIX_PATH` configuras una instalación personalizada, la compilación fallará y mostrará errores como «No se ha podido encontrar AWSSDK» al CMake intentar procesarla `find_package(AWSSDK)` en la tuya`CMakeLists.txt`.

**nota**  
Deep Dive: bibliotecas de tiempo de ejecución de Windows  
Para ejecutar el programa, DLLs se necesitan varios en la ubicación ejecutable del programa:`aws-c-common.dll`,`aws-c-event-stream.dll`,`aws-checksums.dll`,`aws-cpp-sdk-core.dll`, así como cualquier ubicación específica DLLs basada en los componentes del programa (este ejemplo también es obligatorio `aws-cpp-sdk-s3` porque utiliza Amazon S3). La segunda `if` instrucción del `CMakeLists.txt` archivo copia estas bibliotecas de la ubicación de instalación a la ubicación del archivo ejecutable para cumplir con este requisito. `AWSSDK_CPY_DYN_LIBS`es una macro definida por la AWS SDK para C\$1\$1 que se copian los SDK DLLs de la ubicación de instalación a la ubicación ejecutable del programa. Si no DLLs se encuentran en la ubicación ejecutable, se producen excepciones de tiempo de ejecución del tipo «archivo no encontrado». Si encuentra estos errores, revise esta parte del archivo `CMakeLists.txt` para comprobar necesita hacer cambios en su entorno único.

**Para crear la carpeta y los archivos de origen**

1. Cree un and/or proyecto `hello_s3` de directorio para almacenar sus archivos fuente.
**nota**  
Para completar este ejemplo en Visual Studio: elija **Crear nuevo proyecto** y, a continuación, elija **CMake Proyecto**. Asigne un nombre al proyecto `hello_s3`. Este nombre de proyecto se usa en el archivo `CMakeLists.txt`.

1. En esa carpeta, añada un archivo `hello_s3.cpp` que incluya el siguiente código, en el que se indican los buckets de Amazon S3 de su propiedad.

   ```
   #include <aws/core/Aws.h>
   #include <aws/s3/S3Client.h>
   #include <iostream>
   #include <aws/core/auth/AWSCredentialsProviderChain.h>
   using namespace Aws;
   using namespace Aws::Auth;
   
   /*
    *  A "Hello S3" starter application which initializes an Amazon Simple Storage Service (Amazon S3) client
    *  and lists the Amazon S3 buckets in the selected region.
    *
    *  main function
    *
    *  Usage: 'hello_s3'
    *
    */
   
   int main(int argc, char **argv) {
       Aws::SDKOptions options;
       // Optionally change the log level for debugging.
   //   options.loggingOptions.logLevel = Utils::Logging::LogLevel::Debug;
       Aws::InitAPI(options); // Should only be called once.
       int result = 0;
       {
           Aws::Client::ClientConfiguration clientConfig;
           // Optional: Set to the AWS Region (overrides config file).
           // clientConfig.region = "us-east-1";
                  
           // You don't normally have to test that you are authenticated. But the S3 service permits anonymous requests, thus the s3Client will return "success" and 0 buckets even if you are unauthenticated, which can be confusing to a new user. 
           auto provider = Aws::MakeShared<DefaultAWSCredentialsProviderChain>("alloc-tag");
           auto creds = provider->GetAWSCredentials();
           if (creds.IsEmpty()) {
               std::cerr << "Failed authentication" << std::endl;
           }
   
           Aws::S3::S3Client s3Client(clientConfig);
           auto outcome = s3Client.ListBuckets();
   
           if (!outcome.IsSuccess()) {
               std::cerr << "Failed with error: " << outcome.GetError() << std::endl;
               result = 1;
           } else {
               std::cout << "Found " << outcome.GetResult().GetBuckets().size()
                         << " buckets\n";
               for (auto &bucket: outcome.GetResult().GetBuckets()) {
                   std::cout << bucket.GetName() << std::endl;
               }
           }
       }
   
       Aws::ShutdownAPI(options); // Should only be called once.
       return result;
   }
   ```

1. Agregue un archivo `CMakeLists.txt` que especifique el nombre del proyecto, los ejecutables, los archivos de origen y las bibliotecas vinculadas. 

   ```
   # Set the minimum required version of CMake for this project.
   cmake_minimum_required(VERSION 3.13)
   
   # Set the AWS service components used by this project.
   set(SERVICE_COMPONENTS s3)
   
   # Set this project's name.
   project("hello_s3")
   
   # Set the C++ standard to use to build this target.
   # At least C++ 11 is required for the AWS SDK for C++.
   set(CMAKE_CXX_STANDARD 11)
   
   # Use the MSVC variable to determine if this is a Windows build.
   set(WINDOWS_BUILD ${MSVC})
   
   if (WINDOWS_BUILD) # Set the location where CMake can find the installed libraries for the AWS SDK.
       string(REPLACE ";" "/aws-cpp-sdk-all;" SYSTEM_MODULE_PATH "${CMAKE_SYSTEM_PREFIX_PATH}/aws-cpp-sdk-all")
       list(APPEND CMAKE_PREFIX_PATH ${SYSTEM_MODULE_PATH})
   endif ()
   
   # Find the AWS SDK for C++ package.
   find_package(AWSSDK REQUIRED COMPONENTS ${SERVICE_COMPONENTS})
   
   if (WINDOWS_BUILD AND AWSSDK_INSTALL_AS_SHARED_LIBS)
       # Copy relevant AWS SDK for C++ libraries into the current binary directory for running and debugging.
   
       # set(BIN_SUB_DIR "/Debug") # if you are building from the command line you may need to uncomment this
       # and set the proper subdirectory to the executables' location.
   
       AWSSDK_CPY_DYN_LIBS(SERVICE_COMPONENTS "" ${CMAKE_CURRENT_BINARY_DIR}${BIN_SUB_DIR})
   endif ()
   
   add_executable(${PROJECT_NAME}
           hello_s3.cpp)
   
   target_link_libraries(${PROJECT_NAME}
           ${AWSSDK_LINK_LIBRARIES})
   ```

## Paso 2: Compila con CMake
<a name="building-with-cmake"></a>

CMake utiliza la información `CMakeLists.txt` para crear un programa ejecutable.

Le recomendamos que compile la aplicación siguiendo las prácticas estándar de su IDE.

**Para compilar la aplicación en la línea de comandos**

1. Cree un directorio donde **`cmake`** compilará su aplicación.

   ```
   mkdir my_project_build
   ```

1. Cambie al directorio de compilación y ejecute **`cmake`** usando la ruta al directorio de origen de su proyecto.

   ```
   cd my_project_build
   cmake ../
   ```

1. Cuando **`cmake`** haga generado el directorio de compilación, podrá usar **`make`** (**`nmake`** en Windows) o MSBUILD (`msbuild ALL_BUILD.vcxproj` o `cmake --build . --config=Debug`) para compilar su aplicación.

## Paso 3: ejecución
<a name="run-app"></a>

Al ejecutar esta aplicación, se mostrará la salida de la consola con el número total de buckets de Amazon S3 y el nombre de cada bucket.

Le recomendamos que ejecute la aplicación siguiendo las prácticas estándar de su IDE.

**nota**  
¡Recuerde iniciar sesión\$1 Si utiliza el Centro de identidad de IAM para autenticarse, no olvide iniciar sesión con el AWS CLI `aws sso login` comando.

**Para ejecutar el programa mediante la línea de comandos**

1. Cambie al directorio de depuración donde se generó el resultado de la compilación. 

1. Ejecute el programa con el nombre del ejecutable.

   ```
   hello_s3
   ```

Para ver ejemplos adicionales que utilizan el AWS SDK para C\$1\$1, consulte. [Ejemplos guiados de llamadas Servicios de AWS mediante el AWS SDK para C\$1\$1](programming-services.md)