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.

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