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.
# Cómo empezar con el AWS SDK para C\$1\$1
AWS SDK para C\$1\$1 es una biblioteca modularizada, multiplataforma y de código abierto que puede utilizar para conectarse a Amazon Web Services.
Se AWS SDK para C\$1\$1 utiliza [CMake](https://cmake.org/)para admitir múltiples plataformas en varios dominios, incluidos videojuegos, sistemas, dispositivos móviles y dispositivos integrados. CMake es una herramienta de compilación que puedes usar para administrar las dependencias de tu aplicación y crear archivos makefiles adecuados para la plataforma en la que estás creando. CMake elimina las partes de la compilación que no se utilizan en tu plataforma o aplicación.
Antes de ejecutar el código para acceder a AWS los recursos, debe establecer cómo se autentica el código. AWS
+ [Autenticación AWS mediante AWS SDK para C\$1\$1](credentials.md)
Para usarlos AWS SDK para C\$1\$1 en tu código, obtén los ejecutables del SDK compilando directamente la fuente del SDK o usando un administrador de paquetes.
+ [Obtención AWS SDK para C\$1\$1 del código fuente](sdk-from-source.md)
+ [Obtenerla AWS SDK para C\$1\$1 de un administrador de paquetes](sdk-from-pm.md)
Si tiene problemas de compilación al respecto CMake, consulte[Solución de problemas de compilación del AWS SDK para C\$1\$1](troubleshooting-cmake.md).
# Autenticación AWS mediante AWS SDK para C\$1\$1
Debe establecer cómo se autentica su código AWS al desarrollar con. Servicios de AWS Puedes configurar el acceso programático a AWS los recursos de diferentes maneras en función del entorno y del AWS acceso del que dispongas. Para conocer las opciones de todos los métodos principales de autenticación y obtener instrucciones sobre cómo configurarlos para el SDK, consulte [Autenticación y acceso](https://docs.aws.amazon.com/sdkref/latest/guide/access.html) en la *Guía de referencia AWS SDKs y herramientas*.
## Uso de las credenciales de la consola
Para el desarrollo local, recomendamos que los nuevos usuarios utilicen sus credenciales de inicio de sesión AWS de Management Console existentes para acceder a AWS los servicios mediante programación. Tras un flujo de autenticación basado en un navegador, AWS genera credenciales temporales que funcionan en todas las herramientas de desarrollo local, como la AWS CLI y Herramientas de AWS para PowerShell . AWS SDKs Esta función simplifica el proceso de configuración y administración de las credenciales de AWS CLI, especialmente si prefiere la autenticación interactiva en lugar de administrar las claves de acceso a largo plazo.
Si elige este método, siga las instrucciones para iniciar sesión con las credenciales de la consola mediante la AWS CLI. Consulte [Iniciar sesión para el desarrollo AWS local con las credenciales de la consola](https://docs.aws.amazon.com/cli/latest/userguide/cli-configure-sign-in.html) para obtener más información.
Una vez configurada con la AWS CLI, [la cadena de proveedores de credenciales predeterminada](https://docs.aws.amazon.com/sdk-for-cpp/v1/developer-guide/credproviders.html#credproviders-default-credentials-provider-chain) comenzará a utilizar automáticamente el token de inicio de sesión almacenado en caché por la AWS CLI para realizar solicitudes.
## Uso del Centro de identidades de IAM
Este método incluye la instalación del AWS CLI para facilitar la configuración y para iniciar sesión con regularidad en el portal de AWS acceso.
Si elige este método, complete el procedimiento de [autenticación del Centro de Identidad de IAM](https://docs.aws.amazon.com/sdkref/latest/guide/access-sso.html) que se indica en la *Guía de referencia de herramientas AWS SDKs y herramientas*. Una vez completado, el entorno debe contener los siguientes elementos:
+ El AWS CLI, que se utiliza para iniciar una sesión en el portal de AWS acceso antes de ejecutar la aplicación.
+ Un [archivo `config` compartido de AWS](https://docs.aws.amazon.com/sdkref/latest/guide/file-format.html) que tiene un perfil `[default]` con un conjunto de valores de configuración a los que se puede hacer referencia desde el SDK. Para encontrar la ubicación de este archivo, consulte [Ubicación de los archivos compartidos](https://docs.aws.amazon.com/sdkref/latest/guide/file-location.html) en la *Guía de referencia de AWS SDKs and Tools*.
+ El archivo compartido de `config` establece la configuración de [https://docs.aws.amazon.com/sdkref/latest/guide/feature-region.html](https://docs.aws.amazon.com/sdkref/latest/guide/feature-region.html). Esto establece el valor predeterminado Región de AWS que el SDK usa para AWS las solicitudes. Esta región se usa para las solicitudes de servicio del SDK que no tienen especificadas una región.
+ El SDK utiliza la [configuración de proveedor de token de SSO](https://docs.aws.amazon.com/sdkref/latest/guide/feature-sso-credentials.html#feature-sso-credentials-profile) del perfil para adquirir las credenciales antes de enviar las solicitudes a AWS. El `sso_role_name` valor, que es un rol de IAM conectado a un conjunto de permisos del Centro de Identidad de IAM, debería permitir el acceso al Servicios de AWS utilizado en la aplicación.
El siguiente archivo `config` de ejemplo muestra la configuración de un perfil predeterminado con el proveedor de token de SSO. La configuración `sso_session` del perfil hace referencia a la [sección llamada `sso-session`](https://docs.aws.amazon.com/sdkref/latest/guide/file-format.html#section-session). La `sso-session` sección contiene la configuración para iniciar una sesión en el portal de AWS acceso.
```
[default]
sso_session = my-sso
sso_account_id = 111122223333
sso_role_name = SampleRole
region = us-east-1
output = json
[sso-session my-sso]
sso_region = us-east-1
sso_start_url = https://provided-domain.awsapps.com/start
sso_registration_scopes = sso:account:access
```
AWS SDK para C\$1\$1 No es necesario añadir paquetes adicionales (por ejemplo, `SSO` y`SSOOIDC`) a la aplicación para utilizar la autenticación del IAM Identity Center.
### Inicie una sesión en el portal de AWS acceso
Antes de ejecutar una aplicación para acceder Servicios de AWS, necesita una sesión activa en el portal de AWS acceso para que el SDK utilice la autenticación del IAM Identity Center a fin de resolver las credenciales. En función de la duración de las sesiones configuradas, el acceso terminará por caducar y SDK detectará un error de autenticación. Para iniciar sesión en el portal de AWS acceso, ejecute el siguiente comando en. AWS CLI
```
aws sso login
```
Como tiene una configuración de perfil predeterminada, no necesita llamar al comando con una opción `--profile`. Si la configuración del proveedor de token de SSO utiliza un perfil con nombre, el comando es `aws sso login --profile named-profile`.
Para comprobar si ya tiene una sesión activa, ejecute el siguiente AWS CLI comando.
```
aws sts get-caller-identity
```
La respuesta a este comando debe indicar la cuenta y el conjunto de permisos del Centro de identidades de IAM configurados en el archivo compartido `config`.
**nota**
Si ya tiene una sesión activa en el portal de AWS acceso y la ejecuta`aws sso login`, no tendrá que proporcionar credenciales.
Es posible que el proceso de inicio de sesión le pida que permita el AWS CLI acceso a sus datos. Como AWS CLI se basa en el SDK para Python, los mensajes de permiso pueden contener variaciones del `botocore` nombre.
## Información adicional de autenticación
Los usuarios humanos, que también reciben el nombre de *identidades humanas*, son las personas, los administradores, los desarrolladores, los operadores y los consumidores de las aplicaciones. Deben tener una identidad para acceder a sus AWS entornos y aplicaciones. Los usuarios humanos que son miembros de su organización (es decir, usted, el desarrollador) se conocen como *identidades de personal*. Utilice credenciales temporales al acceder AWS. Puede usar un proveedor de identidad para que sus usuarios humanos proporcionen acceso federado a AWS las cuentas asumiendo funciones, que proporcionan credenciales temporales. Para una administración centralizada del acceso, le recomendamos que utilice AWS IAM Identity Center (IAM Identity Center) para administrar el acceso a sus cuentas y los permisos dentro de esas cuentas. Para obtener más alternativas, consulte lo siguiente:
+ Para obtener más información sobre las prácticas recomendadas, consulte [Prácticas recomendadas de seguridad en IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/best-practices.html) en la *Guía del usuario de IAM*.
+ Para crear AWS credenciales de corta duración, consulte [Credenciales de seguridad temporales](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_temp.html) en la Guía del *usuario de IAM*.
+ Para obtener más información sobre otros proveedores de AWS SDK para C\$1\$1 credenciales, consulte los proveedores de [credenciales estandarizados en la Guía](https://docs.aws.amazon.com/sdkref/latest/guide/standardized-credentials.html) de referencia de *herramientas AWS SDKs y herramientas*.
# Obtención AWS SDK para C\$1\$1 del código fuente
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
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- # Repo directory name and packageName
aws-sdk-cpp\aws-cpp-sdk-s3 # Example: Package name is s3
```
## Requisitos previos
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
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
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
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` ..
```
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` ..
```
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
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- # Repo directory name and packageName
aws-sdk-cpp\aws-cpp-sdk-s3 # Example: Package name is s3
```
## Requisitos previos
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
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
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
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
[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
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
#include
#include
#include
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("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
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
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)
# Obtenerla AWS SDK para C\$1\$1 de un administrador de paquetes
**importante**
Si utiliza un administrador de paquetes como homebrew o vcpkg:
Después de actualizar el SDK para C\$1\$1 a una nueva versión, debe volver a compilar cualquier biblioteca o ejecutable que dependa del SDK.
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- # Repo directory name and packageName
aws-sdk-cpp\aws-cpp-sdk-s3 # Example: Package name is s3
```
## Requisitos previos
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.
------
#### [ Linux/macOS ]
Para usar el AWS SDK para C\$1\$1 en Linux/macOS, necesita uno de los siguientes:
+ GNU Compiler Collection (GCC) 4.9 o versiones posteriores o
+ Clang 3.3 o versiones posteriores.
------
#### [ Windows ]
Para usar el AWS SDK para C\$1\$1 en Windows, 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.
------
## Obtención del SDK mediante vcpkg
**importante**
La distribución de vcpkg disponible cuenta con el apoyo de colaboradores externos y no se proporciona a través de ella. AWS La versión más reciente siempre está disponible en la [instalación desde el código fuente](sdk-from-source.md).
[vcpkg](https://github.com/Microsoft/vcpkg) es un administrador de paquetes actualizado y de cuyo mantenimiento se encargan colaboradores externos. Tenga en cuenta que este administrador de paquetes no se proporciona AWS y es posible que no refleje la última versión disponible del. AWS SDK para C\$1\$1 Hay un retraso entre el momento en que se publica una versión AWS y el momento en que está disponible a través de un administrador de paquetes externo. La versión más reciente siempre está disponible en la [instalación desde el código fuente](sdk-from-source.md).
Debe instalar [vcpkg](https://github.com/Microsoft/vcpkg) en su sistema.
+ Descargue y arranque [vcpkg](https://github.com/Microsoft/vcpkg) siguiendo las instrucciones del GitHub archivo readme de vcpkg y sustituyéndolas por las siguientes opciones cuando se le solicite:
+
Como parte de esas instrucciones, se le indicará que introduzca lo siguiente:
```
.\vcpkg\vcpkg install [packages to install]
```
Para instalar el SDK entero, introduzca `.\vcpkg\vcpkg install "aws-sdk-cpp[*]" --recurse` o indique solo los servicios específicos del SDK que desea instalar añadiendo un nombre de paquete entre paréntesis; por ejemplo, `.\vcpkg\vcpkg install "aws-sdk-cpp[s3, ec2]" --recurse`.
La salida muestra un mensaje que incluye lo siguiente:
```
CMake projects should use: "-DCMAKE_TOOLCHAIN_FILE=C:/dev/vcpkg/vcpkg/scripts/buildsystems/vcpkg.cmake"
```
+ Copie el comando completo para usarlo más adelante. `-DCMAKE_TOOLCHAIN_FILE` CMake El GitHub archivo readme de vcpkg también indica dónde usarlo para su conjunto de herramientas.
+ Es posible que también tenga que anotar el tipo de configuración de compilación que ha instalado mediante vcpkg. La salida de la consola muestra la configuración de compilación y la versión del SDK. El siguiente resultado de ejemplo indica que la configuración de compilación es «x86-windows» y que la versión instalada es 1.8. AWS SDK para C\$1\$1
```
The following packages will be built and installed:
aws-sdk-cpp[core,dynamodb,kinesis,s3]:x86-windows -> 1.8.126#6
```
Tras instalar el AWS SDK para C\$1\$1, puede desarrollar su propia aplicación mediante el SDK. En el ejemplo que se muestra en [Creación de una aplicación simple](build-cmake.md), aparecen los buckets de Amazon S3 cuyo propietario es usted.
# Solución de problemas de compilación del AWS SDK para C\$1\$1
Al compilarlo AWS SDK para C\$1\$1 desde el código fuente, pueden surgir algunos de los siguientes problemas comunes de compilación.
**Topics**
+ [CMake Error: no se pudo encontrar el archivo de configuración del paquete proporcionado por "AWSSDK»](#could-not-find-package)
+ [CMake Error: no se pudo encontrar el archivo de carga (y estás usando la versión 1.8 del SDK)](#could-not-load-file)
+ [CMake Error: no se pudo encontrar el archivo de carga](#could-not-load-file2)
+ [Runtime Error: cannot proceed because `aws-*.dll` was not found](#dll-was-not-found)
## CMake Error: no se pudo encontrar el archivo de configuración del paquete proporcionado por "AWSSDK»
CMake genera el siguiente error si no puede encontrar el SDK instalado.
```
1> [CMake] CMake Error at C:\CodeRepos\CMakeProject1\CMakeLists.txt:4 (find_package):
1> [CMake] Could not find a package configuration file provided by "AWSSDK" with any
1> [CMake] of the following names:
1> [CMake]
1> [CMake] AWSSDKConfig.cmake
1> [CMake] awssdk-config.cmake
1> [CMake]
1> [CMake] Add the installation prefix of "AWSSDK" to CMAKE_PREFIX_PATH or set
1> [CMake] "AWSSDK_DIR" to a directory containing one of the above files. If "AWSSDK"
1> [CMake] provides a separate development package or SDK, be sure it has been
1> [CMake] installed.
```
Para resolver este error, indica CMake dónde se encuentra el SDK instalado (por ejemplo, la carpeta que se generó como resultado de la instalación del SDK ([Windows](setup-windows.md), [Linux/macOS](setup-linux.md)). Antes de la primera llamada a `find_package()`, inserte el siguiente comando en su archivo `CMakeLists.txt`. Consulte [Creación de una aplicación sencilla con el AWS SDK para C\$1\$1](build-cmake.md) para ver un ejemplo.
```
list(APPEND CMAKE_PREFIX_PATH "C:\\Program Files (x86)\\aws-cpp-sdk-all\\lib\\cmake")
```
## CMake Error: no se pudo encontrar el archivo de carga (y estás usando la versión 1.8 del SDK)
CMake genera el siguiente error si no puede encontrar las bibliotecas instaladas.
```
1> [CMake] include could not find load file:
1> [CMake]
1> [CMake] C:/Program Files (x86)/aws-cpp-sdk-all/lib/aws-c-common/cmake/static/aws-c-common-targets.cmake
1> [CMake] include could not find load file:
1> [CMake]
1> [CMake] C:/Program Files (x86)/aws-cpp-sdk-all/lib/aws-checksums/cmake/static/aws-checksums-targets.cmake
1> [CMake] include could not find load file:
1> [CMake]
1> [CMake] C:/Program Files (x86)/aws-cpp-sdk-all/lib/aws-checksums/cmake/static/aws-checksums-targets.cmake
```
Para resolver este error, indica CMake dónde se encuentra el SDK instalado (por ejemplo, la carpeta que se generó como resultado de la instalación del SDK ([Windows](setup-windows.md), [Linux/macOS](setup-linux.md)). Antes de la primera llamada a `find_package()`, inserte los siguientes comandos en su archivo `CMakeLists.txt`. Consulte [Creación de una aplicación sencilla con el AWS SDK para C\$1\$1](build-cmake.md) para ver un ejemplo.
```
#Set the location of where Windows can find the installed libraries of the SDK.
if(MSVC)
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()
```
Esta solución solo es válida para la versión 1.8 del SDK, ya que estas dependencias se gestionan de forma diferente en las versiones posteriores. La versión 1.9 resuelve estos problemas al introducir una capa intermedia entre las bibliotecas `aws-sdk-cpp` y `aws-c-*`. Esta nueva capa se denomina `aws-crt-cpp` y es un submódulo de git del SDK para C\$1\$1. `aws-crt-cpp` también tiene las bibliotecas `aws-c-*` (como `aws-c-common`, `aws-checksums`, ` aws-c-event-stream`, etc.) como sus propios submódulos de git. Esto permite que el SDK para C\$1\$1 obtenga todas las bibliotecas CRT de forma recursiva y mejora el proceso de compilación.
## CMake Error: no se pudo encontrar el archivo de carga
CMake genera el siguiente error si no puede encontrar las bibliotecas instaladas.
```
CMake Error at C:/Program Files (x86)/aws-cpp-sdk-all/lib/aws-c-auth/cmake/aws-c-auth-config.cmake:11
(include): include could not find load file:
C:/Program Files (x86)/aws-cpp-sdk-all/lib/aws-c-auth/cmake/static/aws-c-auth-targets.cmake
```
Para resolver este error, pida CMake que cree bibliotecas compartidas. Antes de la primera llamada a `find_package()`, inserte el siguiente comando en su archivo `CMakeLists.txt`. Consulte [Creación de una aplicación sencilla con el AWS SDK para C\$1\$1](build-cmake.md) para ver un ejemplo.
```
set(BUILD_SHARED_LIBS ON CACHE STRING "Link to shared libraries by default.")
```
## Runtime Error: cannot proceed because `aws-*.dll` was not found
CMake genera un error similar al siguiente si no puede encontrar la DLL necesaria.
```
The code execution cannot proceed because aws-cpp-sdk-[dynamodb].dll was not found. Reinstalling the program may fix this problem.
```
Este error se produce porque las bibliotecas o los ejecutables necesarios para el SDK para C\$1\$1 no están disponibles en la misma carpeta que los ejecutables de la aplicación. Para resolver este error, copie la salida de la compilación del SDK en la ubicación del ejecutable. El nombre de archivo DLL específico del error variará en función de AWS los servicios que utilice. Realice *una* de las siguientes acciones siguientes:
+ Copia el contenido de la `/bin` carpeta de AWS SDK para C\$1\$1 instalación a la carpeta de compilación de la aplicación.
+ En el `CMakeLists.txt` archivo, utilice la macro AWSSDK\$1CPY \$1DYN\$1LIBS para copiarlos automáticamente.
Añada una llamada a `AWSSDK_CPY_DYN_LIBS(SERVICE_LIST "" ${CMAKE_CURRENT_BINARY_DIR})` o a `CMakeLists.txt` a su archivo `AWSSDK_CPY_DYN_LIBS(SERVICE_LIST "" ${CMAKE_CURRENT_BINARY_DIR}/${CMAKE_BUILD_TYPE})` para utilizar esta macro para que realice la copia por usted. Consulte [Creación de una aplicación sencilla con el AWS SDK para C\$1\$1](build-cmake.md) para ver un ejemplo.
Elija la ruta de copia correcta para su entorno de compilación. La compilación mediante la línea de comandos suele colocar el resultado de la compilación en una subcarpeta (`/Debug`), pero Visual Studio y otros no suelen hacerlo. IDEs Compruebe dónde están los ejecutables de salida y asegúrese de que la macro se esté copiando en esa ubicación. Al realizar este tipo de cambios, se recomienda eliminar el contenido del directorio de salida de la compilación para disponer de un punto de partida limpio para la siguiente compilación.