Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.
# Commencer à utiliser le AWS SDK pour C\$1\$1
AWS SDK pour C\$1\$1 est une bibliothèque open source modulaire multiplateforme que vous pouvez utiliser pour vous connecter à Amazon Web Services.
Les AWS SDK pour C\$1\$1 utilisations [CMake](https://cmake.org/)pour prendre en charge plusieurs plateformes dans plusieurs domaines, y compris les jeux vidéo, les systèmes, les appareils mobiles et intégrés. CMake est un outil de compilation que vous pouvez utiliser pour gérer les dépendances de votre application et pour créer des makefiles adaptés à la plateforme sur laquelle vous créez. CMake supprime les parties du build qui ne sont pas utilisées pour votre plate-forme ou votre application.
Avant d'exécuter du code pour accéder aux AWS ressources, vous devez établir le mode d'authentification de votre code. AWS
+ [Authentification à AWS l'aide du AWS SDK for C\$1\$1](credentials.md)
Pour utiliser le AWS SDK pour C\$1\$1 dans votre code, procurez-vous les exécutables du SDK en créant directement la source du SDK ou en utilisant un gestionnaire de packages.
+ [Obtenir AWS SDK pour C\$1\$1 le code source](sdk-from-source.md)
+ [Obtenir le AWS SDK pour C\$1\$1 depuis un gestionnaire de packages](sdk-from-pm.md)
Si vous rencontrez des problèmes de compilation concernant CMake, voir[Résolution des problèmes liés à la compilation du AWS SDK for C\$1\$1](troubleshooting-cmake.md).
# Authentification à AWS l'aide du AWS SDK for C\$1\$1
Vous devez définir la manière dont votre code s'authentifie AWS lorsque vous développez avec Services AWS. Vous pouvez configurer l'accès programmatique aux AWS ressources de différentes manières en fonction de l'environnement et de l' AWS accès dont vous disposez. Pour connaître les choix concernant les principales méthodes d'authentification et les instructions relatives à leur configuration pour le SDK, consultez la section [Authentification et accès](https://docs.aws.amazon.com/sdkref/latest/guide/access.html) dans le *guide de référence des outils AWS SDKs et*.
## Utilisation des informations d'identification de console
Pour le développement local, nous recommandons aux nouveaux utilisateurs d'utiliser leurs identifiants de connexion existants à la console de AWS gestion pour accéder aux AWS services par programmation. Après un flux d'authentification basé sur un navigateur, AWS génère des informations d'identification temporaires qui fonctionnent avec les outils de développement locaux tels que la AWS CLI et Outils AWS pour PowerShell . AWS SDKs Cette fonctionnalité simplifie le processus de configuration et de gestion des informations d'identification de la AWS CLI, en particulier si vous préférez l'authentification interactive à la gestion des clés d'accès à long terme.
Si vous choisissez cette méthode, suivez les instructions pour vous connecter à l'aide des informations d'identification de console à l'aide de la AWS CLI. Voir [Connexion pour le développement AWS local à l'aide des informations d'identification de console](https://docs.aws.amazon.com/cli/latest/userguide/cli-configure-sign-in.html) pour plus de détails.
Une fois configurée avec la AWS CLI, [la chaîne de fournisseurs d'informations d'identification par défaut](https://docs.aws.amazon.com/sdk-for-cpp/v1/developer-guide/credproviders.html#credproviders-default-credentials-provider-chain) commencera automatiquement à utiliser le jeton de connexion mis en cache par la AWS CLI pour effectuer des demandes.
## Utilisation d'IAM Identity Center
Cette méthode consiste à installer le AWS CLI pour faciliter la configuration et pour vous connecter régulièrement au portail AWS d'accès.
Si vous choisissez cette méthode, suivez la procédure d'[authentification IAM Identity Center](https://docs.aws.amazon.com/sdkref/latest/guide/access-sso.html) dans le *guide de référence AWS SDKs and Tools*. Ensuite, votre environnement doit contenir les éléments suivants :
+ Le AWS CLI, que vous utilisez pour démarrer une session de portail d' AWS accès avant d'exécuter votre application.
+ [AWS`config`Fichier partagé doté](https://docs.aws.amazon.com/sdkref/latest/guide/file-format.html) d'un `[default]` profil avec un ensemble de valeurs de configuration pouvant être référencées à partir du SDK. Pour connaître l'emplacement de ce fichier, reportez-vous à la section [Emplacement des fichiers partagés](https://docs.aws.amazon.com/sdkref/latest/guide/file-location.html) dans le *Guide de référence des outils AWS SDKs et*.
+ Le `config` fichier partagé définit le [https://docs.aws.amazon.com/sdkref/latest/guide/feature-region.html](https://docs.aws.amazon.com/sdkref/latest/guide/feature-region.html)paramètre. Cela définit la valeur par défaut Région AWS que le SDK utilise pour les AWS demandes. Cette région est utilisée pour les demandes de service du SDK qui ne sont pas spécifiées avec une région à utiliser.
+ Le SDK utilise la [configuration du fournisseur de jetons SSO](https://docs.aws.amazon.com/sdkref/latest/guide/feature-sso-credentials.html#feature-sso-credentials-profile) du profil pour obtenir des informations d'identification avant d'envoyer des demandes à. AWS La `sso_role_name` valeur, qui est un rôle IAM connecté à un ensemble d'autorisations IAM Identity Center, doit autoriser l'accès à l'utilisateur dans Services AWS votre application.
Le `config` fichier d'exemple suivant montre un profil par défaut configuré avec la configuration du fournisseur de jetons SSO. Le `sso_session` paramètre du profil fait référence à la [`sso-session`section](https://docs.aws.amazon.com/sdkref/latest/guide/file-format.html#section-session) nommée. La `sso-session` section contient les paramètres permettant de lancer une session sur le portail AWS d'accès.
```
[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
```
Il AWS SDK pour C\$1\$1 n'est pas nécessaire d'ajouter des packages supplémentaires (tels que `SSO` et`SSOOIDC`) à votre application pour utiliser l'authentification IAM Identity Center.
### Démarrer une session sur le portail AWS d'accès
Avant d'exécuter une application qui y accède Services AWS, vous avez besoin d'une session de portail d' AWS accès active pour que le SDK utilise l'authentification IAM Identity Center pour résoudre les informations d'identification. En fonction de la durée de session que vous avez configurée, votre accès finira par expirer et le SDK rencontrera une erreur d'authentification. Pour vous connecter au portail AWS d'accès, exécutez la commande suivante dans le AWS CLI.
```
aws sso login
```
Étant donné que vous disposez d’une configuration de profil par défaut, il n'est pas nécessaire d'appeler la commande avec l’option `--profile`. Si la configuration de votre fournisseur de jetons SSO utilise un profil nommé, la commande est `aws sso login --profile named-profile`.
Pour vérifier si vous avez déjà une session active, exécutez la AWS CLI commande suivante.
```
aws sts get-caller-identity
```
La réponse à cette commande doit indiquer le compte IAM Identity Center et l'ensemble d'autorisations configurés dans le fichier partagé `config`.
**Note**
Si vous disposez déjà d'une session active sur le portail AWS d'accès et que vous l'exécutez`aws sso login`, il ne vous sera pas demandé de fournir d'informations d'identification.
Le processus de connexion peut vous demander d'autoriser l' AWS CLI accès à vos données. Comme AWS CLI il repose sur le SDK pour Python, les messages d'autorisation peuvent contenir des variantes du `botocore` nom.
## Plus d'informations d'authentification
Les utilisateurs humains, également connus sous le nom *identités humaines, * sont les personnes, les administrateurs, les développeurs, les opérateurs et les consommateurs de vos applications. Ils doivent disposer d'une identité pour accéder à vos AWS environnements et applications. Les utilisateurs humains membres de votre organisation sont également appelés *identités du personnel*, c'est-à-dire vous, le développeur. Utilisez des informations d'identification temporaires lors de l'accès AWS. Vous pouvez utiliser un fournisseur d'identité pour vos utilisateurs humains afin de fournir un accès fédéré aux AWS comptes en assumant des rôles fournissant des informations d'identification temporaires. Pour une gestion centralisée des accès, nous vous recommandons d'utiliser AWS IAM Identity Center (IAM Identity Center) pour gérer l'accès à vos comptes et les autorisations associées à ces comptes. Pour d'autres alternatives, consultez les rubriques suivantes :
+ Pour en savoir plus sur les bonnes pratiques, consultez [Bonnes pratiques de sécurité dans IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/best-practices.html) dans le *Guide de l'utilisateur IAM*.
+ Pour créer des AWS informations d'identification à court terme, consultez la section [Informations d'identification de sécurité temporaires](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_temp.html) dans le *guide de l'utilisateur IAM*.
+ Pour en savoir plus sur les autres fournisseurs d' AWS SDK pour C\$1\$1 informations d'identification, consultez la section [Fournisseurs d'informations d'identification standardisés](https://docs.aws.amazon.com/sdkref/latest/guide/standardized-credentials.html) dans le guide de *référence sur les outils AWS SDKs et*.
# Obtenir AWS SDK pour C\$1\$1 le code source
Vous pouvez utiliser le code AWS SDK pour C\$1\$1 à partir de votre code en créant d'abord le SDK à partir des sources, puis en l'installant localement.
**Présentation du processus**
| Procédure générale | Processus détaillé |
| --- | --- |
| [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/sdk-for-cpp/v1/developer-guide/sdk-from-source.html) | Commencez par créer le SDK à partir des sources et installez-le. [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/sdk-for-cpp/v1/developer-guide/sdk-from-source.html) |
| [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/sdk-for-cpp/v1/developer-guide/sdk-from-source.html) | Développez ensuite votre propre application à l'aide du SDK. [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/sdk-for-cpp/v1/developer-guide/sdk-from-source.html) |
# Création du AWS SDK pour C\$1\$1 sous Windows
Pour configurer le AWS SDK pour C\$1\$1, vous pouvez créer vous-même le SDK directement à partir de la source ou télécharger les bibliothèques à l'aide d'un gestionnaire de packages.
La source du SDK est séparée en packages individuels par service. L'installation de l'ensemble du SDK peut prendre jusqu'à une heure. L'installation uniquement du sous-ensemble spécifique de services utilisé par votre programme réduit le temps d'installation et réduit également la taille du disque. Pour choisir les services à installer, vous devez connaître le nom du package de chaque service utilisé par votre programme. Vous pouvez consulter la liste des répertoires de packages à l'adresse [https://github.com/aws/aws-sdk-cpp](https://github.com/aws/aws-sdk-cpp)on GitHub. Le nom du package est le suffixe du nom du répertoire du service.
```
aws-sdk-cpp\aws-cpp-sdk- # Repo directory name and packageName
aws-sdk-cpp\aws-cpp-sdk-s3 # Example: Package name is s3
```
## Conditions préalables
Vous avez besoin d'un minimum de 4 Go de RAM pour créer certains des AWS clients les plus importants. Il se peut que le SDK ne parvienne pas à s'appuyer sur les types d'instances Amazon EC2 t2.micro*,* t2.small et sur d'autres *types* d'instances de petite taille en raison d'une mémoire insuffisante.
Pour utiliser le AWS SDK pour C\$1\$1, vous avez besoin de l'un des éléments suivants :
+ Microsoft Visual Studio 2015 ou version ultérieure,
+ GNU Compiler Collection (GCC) 4.9 ou version ultérieure, ou
+ Clang 3.3 ou version ultérieure.
## Création du SDK pour Windows avec curl
Sous Windows, le SDK est créé avec [WinHTTP](https://msdn.microsoft.com/en-us/library/windows/desktop/aa382925%28v=vs.85%29.aspx) comme client HTTP par défaut. Cependant, WinHTTP 1.0 ne prend pas en charge le streaming bidirectionnel HTTP/2, qui est requis pour certains, tels qu' Services AWS Amazon Transcribe et Amazon Lex. Ainsi, il est parfois nécessaire de créer un support curl avec le SDK. Pour voir toutes les options de téléchargement de curl disponibles, voir [Versions et téléchargements de curl](https://curl.se/download.html). L'une des méthodes pour créer le SDK avec le support curl est la suivante :
**Pour créer le SDK avec le support de la bibliothèque curl inclus**
1. Accédez à [curl pour Windows](https://curl.se/windows/) et téléchargez le package binaire curl pour Microsoft Windows.
1. Décompressez le package dans un dossier de votre ordinateur, par exemple,`C:\curl`.
1. Accédez aux [certificats CA extraits de Mozilla](http://curl.haxx.se/docs/caextract.html) et téléchargez le `cacert.pem` fichier. Ce fichier PEM (Privacy Enhanced Mail) contient un ensemble de certificats numériques valides utilisés pour vérifier l'authenticité de sites Web sécurisés. Les certificats sont distribués par des sociétés d'autorité de certification (CA) telles que GlobalSign Verisign.
1. Déplacez le `cacert.pem` fichier vers le `bin` sous-dossier que vous avez décompressé lors d'une étape précédente, par exemple. `C:\curl\bin` Renommez le fichier en`curl-ca-bundle.crt`.
De plus, le Microsoft Build Engine (MSBuild) doit être capable de localiser la boucle `dll` dans la procédure qui suit. Par conséquent, vous devez ajouter le chemin du `bin` dossier curl à votre variable d'`PATH`environnement Windows, `set PATH=%PATH%;C:\curl\bin` par exemple. Vous devez l'ajouter chaque fois que vous ouvrez une nouvelle invite de commande pour créer le SDK. Vous pouvez également définir la variable d'environnement globalement dans les paramètres de votre système Windows afin que le paramètre soit mémorisé.
Lors de *la création du SDK à partir des sources* dans la procédure qui suit, reportez-vous à l'étape 5 (Générer les fichiers de construction) pour connaître la syntaxe de commande requise pour intégrer curl dans votre SDK.
Lorsque vous écrivez votre code, vous devez [Configuration du AWS SDK pour les clients du service C\$1\$1 dans le code](client-config.md) définir `caFile` l'emplacement de votre fichier de certificat. Pour un exemple d'utilisation d'Amazon Transcribe, consultez le *référentiel [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)d'exemples de AWS code* sur. GitHub
## Création du SDK à partir des sources
Vous pouvez créer le SDK à partir des sources à l'aide d'outils de ligne de commande. À l'aide de cette méthode, vous pouvez personnaliser la version de votre SDK. Pour plus d'informations sur les options disponibles, consultez la section [CMake Paramètres](cmake-params.md). Il y a trois étapes principales. Tout d'abord, vous créez les fichiers à l'aide de CMake. Ensuite, vous pouvez MSBuild créer les fichiers binaires du SDK qui fonctionnent avec votre système d'exploitation et créer une chaîne d'outils. Troisièmement, vous installez ou copiez les fichiers binaires au bon endroit sur la machine de développement.
**Pour créer le SDK à partir des sources**
1. Installez [CMake](https://cmake.org/)(version minimale 3.13) et les outils de compilation appropriés pour votre plateforme. Il est recommandé d'ajouter `cmake` à votre`PATH`. Pour vérifier votre version de CMake, ouvrez une invite de commande et exécutez la commande **cmake --version**
1. Dans une invite de commande, accédez au dossier dans lequel vous souhaitez stocker le SDK.
1. Obtenez le dernier code source.
La version 1.11 utilise des sous-modules git pour encapsuler les dépendances externes. Cela inclut les [bibliothèques CRT](https://docs.aws.amazon.com/sdkref/latest/guide/common-runtime.html) décrites dans le *guide de référence AWS SDKs et Tools*.
Téléchargez ou clonez la source du SDK depuis [https://github.com/aws/aws-sdk-cpp](https://github.com/aws/aws-sdk-cpp): GitHub
+ Cloner avec Git : HTTPS
```
git clone --recurse-submodules https://github.com/aws/aws-sdk-cpp
```
+ Cloner avec Git : SSH
```
git clone --recurse-submodules git@github.com:aws/aws-sdk-cpp.git
```
1. Nous vous recommandons de stocker les fichiers de compilation générés en dehors du répertoire source du SDK. Créez un nouveau répertoire dans lequel stocker les fichiers de compilation et naviguez jusqu'à ce dossier.
```
mkdir sdk_build
cd sdk_build
```
1. Générez les fichiers de compilation en exécutant`cmake`. Spécifiez sur la ligne de `cmake` commande si vous souhaitez créer une version *Debug* ou *Release*. `Debug`Tout au long de cette procédure, choisissez d'exécuter une configuration de débogage du code de votre application. `Release`Tout au long de cette procédure, choisissez d'exécuter une configuration de version du code de votre application. Pour Windows, l'emplacement d'installation du SDK est généralement`\Program Files (x86)\aws-cpp-sdk-all\`. Syntaxe de commande :
`{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}`
Pour d'autres méthodes de modification de la sortie de compilation, consultez la section [CMakeParamètres](cmake-params.md).
Pour générer les fichiers de compilation, effectuez l'une des opérations suivantes :
+ **Générer les fichiers de construction (tous Services AWS)** *: pour créer l'intégralité du SDK, exécutez cmake, en spécifiant s'il faut créer une version *Debug ou Release*.* Par exemple :
```
cmake "..\aws-sdk-cpp" -DCMAKE_BUILD_TYPE=Debug -DCMAKE_PREFIX_PATH="C:\Program Files (x86)\aws-cpp-sdk-all"
```
+ **Générer des fichiers de compilation (sous-ensemble Services AWS)** : pour créer uniquement un service ou des packages de services particuliers pour le SDK, ajoutez le CMake [BUILD UNIQUEMENT](cmake-params.md#cmake-build-only) paramètre en séparant les noms des services par des points-virgules. L'exemple suivant crée uniquement le package de services Amazon S3 :
```
cmake ..\aws-sdk-cpp -DCMAKE_BUILD_TYPE=Debug -DBUILD_ONLY="s3" -DCMAKE_PREFIX_PATH="C:\Program Files (x86)\aws-cpp-sdk-all"
```
+ **Générer des fichiers de compilation (avec curl)** : après avoir rempli les conditions préalables à curl, trois options de ligne de commande cmake supplémentaires sont nécessaires pour inclure le support de curl dans le SDK :,, et. [FORCE\$1CURL](cmake-params.md#cmake-force-curl) [CURL\$1INCLUDE\$1DIR](cmake-params.md#cmake-curl-include-dir) [CURL\$1LIBRARY](cmake-params.md#cmake-curl-library) Par exemple :
```
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"
```
**Note**
Si le message d'erreur « Impossible de créer des bibliothèques tierces » s'affiche, vérifiez votre version de CMake en exécutant**cmake --version**. Vous devez utiliser la version CMake minimale 3.13.
1. Créez les fichiers binaires du SDK. Si vous créez l'intégralité du SDK, cette étape peut prendre une heure ou plus. Syntaxe de commande :
`{path to cmake if not in PATH} --build . --config=[Debug | Release]`
```
cmake --build . --config=Debug
```
**Note**
Si vous rencontrez l'erreur L'exécution du code ne peut pas continuer... dll introuvable. La réinstallation du programme peut résoudre ce problème. » , réessayez la `cmake` commande.
1. Ouvrez une invite de commande avec des privilèges d'**administrateur** pour installer le SDK à l'emplacement spécifié précédemment à l'aide du `CMAKE_PREFIX_PATH` paramètre. Syntaxe de commande :
`{path to cmake if not in PATH} --install . --config=[Debug | Release]`
```
cmake --install . --config=Debug
```
## Création pour Android sous Windows
Pour créer pour Android, ajoutez-le `-DTARGET_ARCH=ANDROID` à votre ligne de `cmake` commande. AWS SDK pour C\$1\$1 Il inclut un fichier de CMake chaîne d'outils qui inclut ce dont vous avez besoin en faisant référence aux variables d'environnement appropriées ()`ANDROID_NDK`.
Pour créer le SDK pour Android sous Windows, vous devez l'`cmake`exécuter à partir d'une invite de commande de développeur de Visual Studio (2015 ou version ultérieure). Vous aurez également besoin que NMAKE [NMAKE soit](https://docs.microsoft.com/en-us/cpp/build/reference/nmake-reference?view=msvc-160) installé et que les commandes soient présentes **`git`**`patch`****dans votre chemin. Si Git est installé sur un système Windows, vous le trouverez probablement **`patch`**dans un répertoire frère (`.../Git/usr/bin/`). Une fois que vous aurez vérifié ces exigences, votre ligne de `cmake` commande changera légèrement pour utiliser NMAKE.
```
cmake -G "NMake Makefiles" `-DTARGET_ARCH=ANDROID` ..
```
NMAKE construit en série. Pour créer plus rapidement, nous vous recommandons d'installer JOM comme alternative à NMAKE, puis de modifier l'`cmake`invocation comme suit :
```
cmake -G "NMake Makefiles JOM" `-DTARGET_ARCH=ANDROID` ..
```
Pour un exemple d'application, voir [Configuration d'une application Android avec AWS SDK pour C\$1\$1](https://aws.amazon.com/blogs/developer/setting-up-an-android-application-with-aws-sdk-for-c/)
# Création du sous AWS SDK pour C\$1\$1 Linux/macOS
Pour configurer le AWS SDK pour C\$1\$1, vous pouvez créer vous-même le SDK directement à partir de la source ou télécharger les bibliothèques à l'aide d'un gestionnaire de packages.
La source du SDK est séparée en packages individuels par service. L'installation de l'ensemble du SDK peut prendre jusqu'à une heure. L'installation uniquement du sous-ensemble spécifique de services utilisé par votre programme réduit le temps d'installation et réduit également la taille du disque. Pour choisir les services à installer, vous devez connaître le nom du package de chaque service utilisé par votre programme. Vous pouvez consulter la liste des répertoires de packages à l'adresse [https://github.com/aws/aws-sdk-cpp](https://github.com/aws/aws-sdk-cpp)on GitHub. Le nom du package est le suffixe du nom du répertoire du service.
```
aws-sdk-cpp\aws-cpp-sdk- # Repo directory name and packageName
aws-sdk-cpp\aws-cpp-sdk-s3 # Example: Package name is s3
```
## Conditions préalables
Vous avez besoin d'un minimum de 4 Go de RAM pour créer certains des AWS clients les plus importants. Il se peut que le SDK ne parvienne pas à s'appuyer sur les types d'instances Amazon EC2 t2.micro*,* t2.small et sur d'autres *types* d'instances de petite taille en raison d'une mémoire insuffisante.
Pour utiliser le AWS SDK pour C\$1\$1, vous avez besoin de l'un des éléments suivants :
+ GNU Compiler Collection (GCC) 4.9 ou version ultérieure, ou
+ Clang 3.3 ou version ultérieure.
## Exigences supplémentaires pour les systèmes Linux
Vous devez disposer des fichiers d'en-tête (`-dev`packages) pour`libcurl`,`libopenssl`,`libuuid`, et`zlib`, éventuellement, `libpulse` pour le support Amazon Polly. Vous pouvez trouver les packages en utilisant le gestionnaire de packages de votre système.
**Pour installer les packages sur des systèmes basés sur *Debian/Ubuntu***
+
```
sudo apt-get install libcurl4-openssl-dev libssl-dev uuid-dev zlib1g-dev libpulse-dev
```
**Pour installer les packages sur des *systèmes Linux/Redhat/Fedora/CentOS basés sur Amazon***
+
```
sudo yum install libcurl-devel openssl-devel libuuid-devel pulseaudio-libs-devel
```
## Création du SDK à partir des sources
Vous pouvez créer le SDK à partir des sources à l'aide d'outils de ligne de commande au lieu d'utiliser vcpkg. À l'aide de cette méthode, vous pouvez personnaliser la version de votre SDK. Pour plus d'informations sur les options disponibles, consultez la section [CMake Paramètres](cmake-params.md).
**Pour créer le SDK à partir des sources**
1. Installez [CMake](https://cmake.org/)(version minimale 3.13) et les outils de compilation appropriés pour votre plateforme. Il est recommandé d'ajouter `cmake` à votre`PATH`. Pour vérifier votre version de CMake, ouvrez une invite de commande et exécutez la commande **cmake --version**
1. Dans une invite de commande, accédez au dossier dans lequel vous souhaitez stocker le SDK.
1. Obtenez le dernier code source.
La version 1.11 utilise des sous-modules git pour encapsuler les dépendances externes. Cela inclut les [bibliothèques CRT](https://docs.aws.amazon.com/sdkref/latest/guide/common-runtime.html) décrites dans le *guide de référence AWS SDKs et Tools*.
Téléchargez ou clonez la source du SDK depuis [https://github.com/aws/aws-sdk-cpp](https://github.com/aws/aws-sdk-cpp): GitHub
+ Cloner avec Git : HTTPS
```
git clone --recurse-submodules https://github.com/aws/aws-sdk-cpp
```
+ Cloner avec Git : SSH
```
git clone --recurse-submodules git@github.com:aws/aws-sdk-cpp.git
```
1. Nous vous recommandons de stocker les fichiers de compilation générés en dehors du répertoire source du SDK. Créez un nouveau répertoire dans lequel stocker les fichiers de compilation et naviguez jusqu'à ce dossier.
```
mkdir sdk_build
cd sdk_build
```
1. Générez les fichiers de compilation en exécutant`cmake`. Spécifiez sur la ligne de `cmake` commande si vous souhaitez créer une version *Debug* ou *Release*. `Debug`Tout au long de cette procédure, choisissez d'exécuter une configuration de débogage du code de votre application. `Release`Tout au long de cette procédure, choisissez d'exécuter une configuration de version du code de votre application. Syntaxe de commande :
`{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}`
Pour d'autres méthodes de modification de la sortie de compilation, consultez la section [CMakeParamètres](cmake-params.md).
**Note**
Lorsque vous compilez sur un Mac avec un système de fichiers qui ne distingue pas les majuscules et minuscules, vérifiez le résultat de la `pwd` commande dans le répertoire dans lequel vous exécutez le build. Assurez-vous que le `pwd` résultat utilise des majuscules et minuscules pour les noms de répertoire tels que `/Users` et`Documents`.
Pour générer les fichiers de compilation, effectuez l'une des opérations suivantes :
+ **Générer les fichiers de construction (tous Services AWS)** *: pour créer l'intégralité du SDK, exécutez cmake, en spécifiant s'il faut créer une version *Debug ou Release*.* Par exemple :
```
cmake ../aws-sdk-cpp -DCMAKE_BUILD_TYPE=Debug -DCMAKE_PREFIX_PATH=/usr/local/ -DCMAKE_INSTALL_PREFIX=/usr/local/
```
+ **Générer des fichiers de compilation (sous-ensemble Services AWS)** : pour créer uniquement un service ou des packages de services particuliers pour le SDK, ajoutez le CMake [BUILD UNIQUEMENT](cmake-params.md#cmake-build-only) paramètre en séparant les noms des services par des points-virgules. L'exemple suivant crée uniquement le package de services Amazon S3 :
```
cmake ../aws-sdk-cpp -DCMAKE_BUILD_TYPE=Debug -DCMAKE_PREFIX_PATH=/usr/local/ -DCMAKE_INSTALL_PREFIX=/usr/local/ -DBUILD_ONLY="s3"
```
**Note**
Si le message d'erreur « Impossible de créer des bibliothèques tierces » s'affiche, vérifiez votre version de CMake en exécutant**cmake --version**. Vous devez utiliser la version CMake minimale 3.13.
1. Créez les fichiers binaires du SDK. Si vous créez l'intégralité du SDK, l'opération peut prendre une heure ou plus.
```
cmake --build . --config=Debug
```
1. Installez le SDK. Vous devrez peut-être augmenter les privilèges en fonction de l'emplacement où vous avez choisi d'effectuer l'installation.
```
cmake --install . --config=Debug
```
## Création pour Android sous Linux
Pour créer pour Android, ajoutez-le `-DTARGET_ARCH=ANDROID` à votre ligne de `cmake` commande. AWS SDK pour C\$1\$1 Il inclut un fichier de CMake chaîne d'outils qui inclut ce dont vous avez besoin en faisant référence aux variables d'environnement appropriées ()`ANDROID_NDK`. Pour un exemple d'application, voir [Configuration d'une application Android avec AWS SDK pour C\$1\$1](https://aws.amazon.com/blogs/developer/setting-up-an-android-application-with-aws-sdk-for-c/)
# Création d'une application simple à l'aide du AWS SDK pour C\$1\$1
[CMake](https://cmake.org/)est un outil de compilation que vous utilisez pour gérer les dépendances de votre application et pour créer des makefiles adaptés à la plate-forme sur laquelle vous créez. Vous pouvez l'utiliser CMake pour créer et créer des projets à l'aide du AWS SDK pour C\$1\$1.
Cet exemple indique les compartiments Amazon S3 que vous possédez. Dans cet exemple, il n'est pas nécessaire d'avoir un compartiment Amazon S3 dans votre AWS compte, mais ce sera bien plus intéressant si vous en avez au moins un. Consultez [Create a bucket](https://docs.aws.amazon.com/AmazonS3/latest/userguide/creating-bucket.html) dans le *guide de l'utilisateur d'Amazon Simple Storage Service* si vous n'en avez pas déjà un.
## Étape 1 : Écrire le code
Cet exemple consiste en un dossier contenant un fichier source (`hello_s3.cpp`) et un `CMakeLists.txt` fichier. Le programme utilise Amazon S3 pour communiquer des informations sur les compartiments de stockage. Ce code est également disponible dans le [référentiel d'exemples de AWS code](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code/s3/hello_s3) sur GitHub.
Vous pouvez définir de nombreuses options dans un fichier de configuration de `CMakeLists.txt` build. Pour plus d'informations, consultez le [CMakedidacticiel](https://cmake.org/cmake-tutorial/) sur le CMake site Web.
**Note**
Deep Dive : réglage `CMAKE_PREFIX_PATH`
Par défaut, AWS SDK pour C\$1\$1 les plateformes macOS, Linux, Android et autres plateformes non Windows sont installées dans `/usr/local` et Windows sont installées dans`\Program Files (x86)\aws-cpp-sdk-all`.
Lorsque vous installez le AWS SDK dans ces emplacements standard, il trouve CMake automatiquement les ressources nécessaires. Toutefois, si vous installez le AWS SDK dans un emplacement personnalisé, vous devez indiquer CMake où se trouvent les ressources suivantes issues de la création du SDK :
`AWSSDKConfig.cmake`: fichier de configuration qui indique CMake comment rechercher et utiliser les bibliothèques du AWS SDK dans votre projet. Sans ce fichier, CMake impossible de localiser les fichiers d'en-tête du AWS SDK, de créer un lien vers les bibliothèques du AWS SDK ou de configurer les indicateurs de compilateur appropriés.
(pour les versions 1.8 et antérieures) Emplacement des dépendances :`aws-c-event-stream`,`aws-c-common`, `aws-checksums`
Pour définir un chemin d'installation personnalisé :
```
cmake -DCMAKE_PREFIX_PATH=/path/to/your/aws-sdk-installation /path/to/project/you/are/building
```
Si vous ne définissez pas `CMAKE_PREFIX_PATH` d'installation personnalisée, votre compilation échouera avec des erreurs telles que « Impossible de trouver AWSSDK » lorsque vous CMake tenterez de traiter `find_package(AWSSDK)` votre fichier`CMakeLists.txt`.
**Note**
Approfondissement : bibliothèques Windows Runtime
Pour exécuter votre programme, plusieurs éléments DLLs sont nécessaires dans son emplacement exécutable :`aws-c-common.dll`,,`aws-c-event-stream.dll`, `aws-checksums.dll``aws-cpp-sdk-core.dll`, ainsi que tout élément spécifique DLLs basé sur les composants de votre programme (cet exemple l'exige également `aws-cpp-sdk-s3` car il utilise Amazon S3). La deuxième `if` instruction du `CMakeLists.txt` fichier copie ces bibliothèques de l'emplacement d'installation vers l'emplacement exécutable pour satisfaire à cette exigence. `AWSSDK_CPY_DYN_LIBS`est une macro définie par AWS SDK pour C\$1\$1 laquelle le SDK est copié DLLs de l'emplacement d'installation vers l'emplacement exécutable de votre programme. S' DLLs ils ne se trouvent pas dans l'emplacement de l'exécutable, les exceptions d'exécution « fichier introuvable » se produisent. Passez en revue cette partie du `CMakeLists.txt` fichier pour déterminer les modifications nécessaires à votre environnement unique si vous rencontrez ces erreurs.
**Pour créer le dossier et les fichiers source**
1. Créez un and/or projet de `hello_s3` répertoire pour contenir vos fichiers sources.
**Note**
Pour compléter cet exemple dans Visual Studio : choisissez **Create New Project**, puis **CMake Project**. Appelez le projet `hello_s3`. Ce nom de projet est utilisé dans le `CMakeLists.txt` fichier.
1. Dans ce dossier, ajoutez un `hello_s3.cpp` fichier contenant le code suivant, qui indique les compartiments Amazon S3 que vous possédez.
```
#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. Ajoutez un `CMakeLists.txt` fichier qui indique le nom, les exécutables, les fichiers source et les bibliothèques liées de votre projet.
```
# 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})
```
## Étape 2 : Construisez avec CMake
CMake utilise les informations contenues `CMakeLists.txt` pour créer un programme exécutable.
Nous vous recommandons de créer l'application en suivant les pratiques standard de votre IDE.
**Pour créer l'application à partir de la ligne de commande**
1. Créez un répertoire dans lequel **`cmake`**vous allez créer votre application.
```
mkdir my_project_build
```
1. Accédez au répertoire de construction et exécutez **`cmake`**en utilisant le chemin d'accès au répertoire source de votre projet.
```
cd my_project_build
cmake ../
```
1. Après avoir **`cmake`**généré votre répertoire de construction, vous pouvez utiliser **`make`**(ou **`nmake`**sous Windows) ou MSBUILD (`msbuild ALL_BUILD.vcxproj`ou`cmake --build . --config=Debug`) pour créer votre application.
## Étape 3 : Exécuter
Lorsque vous exécutez cette application, elle affiche une sortie de console répertoriant le nombre total de compartiments Amazon S3 et le nom de chaque compartiment.
Nous vous recommandons d'exécuter l'application conformément aux pratiques standard de votre IDE.
**Note**
N'oubliez pas de vous connecter \$1 Si vous utilisez IAM Identity Center pour vous authentifier, n'oubliez pas de vous connecter à l'aide de la AWS CLI `aws sso login` commande.
**Pour exécuter le programme via la ligne de commande**
1. Accédez au répertoire Debug dans lequel le résultat de la compilation a été généré.
1. Exécutez le programme en utilisant le nom de l'exécutable.
```
hello_s3
```
Pour d'autres exemples d'utilisation du AWS SDK pour C\$1\$1, voir[Exemples guidés d'appels Services AWS à l'aide du AWS SDK for C\$1\$1](programming-services.md).
# Obtenir le AWS SDK pour C\$1\$1 depuis un gestionnaire de packages
**Important**
Si vous utilisez un gestionnaire de paquets comme homebrew ou vcpkg :
Après avoir mis à jour le SDK pour C\$1\$1 vers une nouvelle version, vous devez recompiler toute bibliothèque ou exécutable dépendant du SDK.
Pour configurer le AWS SDK pour C\$1\$1, vous pouvez créer vous-même le SDK directement à partir de la source ou télécharger les bibliothèques à l'aide d'un gestionnaire de packages.
La source du SDK est séparée en packages individuels par service. L'installation de l'ensemble du SDK peut prendre jusqu'à une heure. L'installation uniquement du sous-ensemble spécifique de services utilisé par votre programme réduit le temps d'installation et réduit également la taille du disque. Pour choisir les services à installer, vous devez connaître le nom du package de chaque service utilisé par votre programme. Vous pouvez consulter la liste des répertoires de packages à l'adresse [https://github.com/aws/aws-sdk-cpp](https://github.com/aws/aws-sdk-cpp)on GitHub. Le nom du package est le suffixe du nom du répertoire du service.
```
aws-sdk-cpp\aws-cpp-sdk- # Repo directory name and packageName
aws-sdk-cpp\aws-cpp-sdk-s3 # Example: Package name is s3
```
## Conditions préalables
Vous avez besoin d'un minimum de 4 Go de RAM pour créer certains des AWS clients les plus importants. Il se peut que le SDK ne parvienne pas à s'appuyer sur les types d'instances Amazon EC2 t2.micro*,* t2.small et sur d'autres *types* d'instances de petite taille en raison d'une mémoire insuffisante.
------
#### [ Linux/macOS ]
Pour l' AWS SDK pour C\$1\$1 utiliser sous Linux/macOS, vous avez besoin de l'un des éléments suivants :
+ GNU Compiler Collection (GCC) 4.9 ou version ultérieure, ou
+ Clang 3.3 ou version ultérieure.
------
#### [ Windows ]
Pour utiliser AWS SDK pour C\$1\$1 le sous Windows, vous avez besoin de l'un des éléments suivants :
+ Microsoft Visual Studio 2015 ou version ultérieure,
+ GNU Compiler Collection (GCC) 4.9 ou version ultérieure, ou
+ Clang 3.3 ou version ultérieure.
------
## Obtenez le SDK à l'aide de vcpkg
**Important**
La distribution vcpkg disponible est prise en charge par des contributeurs externes et n'est pas fournie via. AWS La version la plus récente est toujours disponible via l'[installation depuis le code source](sdk-from-source.md).
[vcpkg](https://github.com/Microsoft/vcpkg) est un gestionnaire de paquets mis à jour et maintenu par des contributeurs externes. Notez que ce gestionnaire de packages n'est pas fourni AWS et peut ne pas refléter la dernière version disponible pour le AWS SDK pour C\$1\$1. Il existe un délai entre le moment où une version est publiée par un gestionnaire de packages externe AWS et le moment où elle est disponible par le biais d'un gestionnaire de packages externe. La version la plus récente est toujours disponible via l'[installation depuis le code source](sdk-from-source.md).
Vous devez installer [vcpkg](https://github.com/Microsoft/vcpkg) sur votre système.
+ Téléchargez et démarrez [vcpkg](https://github.com/Microsoft/vcpkg) en suivant les instructions du GitHub fichier Readme de vcpkg, en remplaçant les options suivantes lorsque vous y êtes invité :
+
Dans le cadre de ces instructions, vous êtes invité à saisir :
```
.\vcpkg\vcpkg install [packages to install]
```
Pour installer l'intégralité du SDK, entrez `.\vcpkg\vcpkg install "aws-sdk-cpp[*]" --recurse` ou indiquez uniquement les services spécifiques du SDK à installer en ajoutant un nom de package entre crochets, par exemple, `.\vcpkg\vcpkg install "aws-sdk-cpp[s3, ec2]" --recurse`
La sortie affiche un message comprenant les éléments suivants :
```
CMake projects should use: "-DCMAKE_TOOLCHAIN_FILE=C:/dev/vcpkg/vcpkg/scripts/buildsystems/vcpkg.cmake"
```
+ Copiez la `-DCMAKE_TOOLCHAIN_FILE` commande complète pour l'utiliser CMake ultérieurement. Le GitHub fichier Readme de vcpkg indique également où l'utiliser pour votre jeu d'outils.
+ Vous devrez peut-être également noter le type de configuration de build que vous avez installé via vcpkg. La sortie de console indique la configuration de compilation et la version du SDK. L'exemple de sortie suivant indique que la configuration de construction est « x86-windows » et que la AWS SDK pour C\$1\$1 version installée est 1.8.
```
The following packages will be built and installed:
aws-sdk-cpp[core,dynamodb,kinesis,s3]:x86-windows -> 1.8.126#6
```
Après avoir installé le AWS SDK pour C\$1\$1, vous pouvez développer votre propre application à l'aide du SDK. L'exemple présenté dans les [Création d'une application simple](build-cmake.md) rapports indique les compartiments Amazon S3 que vous possédez.
# Résolution des problèmes liés à la compilation du AWS SDK for C\$1\$1
Lors AWS SDK pour C\$1\$1 de la création du fichier à partir des sources, certains des problèmes de compilation courants suivants peuvent survenir.
**Topics**
+ [
## CMake Erreur : Impossible de trouver le fichier de configuration du package fourni par « AWSSDK »
](#could-not-find-package)
+ [
## CMake Erreur : Impossible de trouver le fichier de chargement (et vous utilisez la version 1.8 du SDK)
](#could-not-load-file)
+ [
## CMake Erreur : Impossible de trouver le fichier de chargement
](#could-not-load-file2)
+ [
## Erreur d'exécution : impossible de continuer car `aws-*.dll` introuvable
](#dll-was-not-found)
## CMake Erreur : Impossible de trouver le fichier de configuration du package fourni par « AWSSDK »
CMake génère l'erreur suivante s'il ne trouve pas le SDK installé.
```
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.
```
Pour résoudre cette erreur, indiquez CMake où se trouve le SDK installé (par exemple, le dossier généré suite à l'installation du SDK ([Windows](setup-windows.md), [Linux/macOS](setup-linux.md)). Avant votre premier appel, insérez la commande suivante `find_package()` dans votre `CMakeLists.txt` fichier. Consultez [Création d'une application simple à l'aide du AWS SDK pour C\$1\$1](build-cmake.md) pour obtenir un exemple.
```
list(APPEND CMAKE_PREFIX_PATH "C:\\Program Files (x86)\\aws-cpp-sdk-all\\lib\\cmake")
```
## CMake Erreur : Impossible de trouver le fichier de chargement (et vous utilisez la version 1.8 du SDK)
CMake génère l'erreur suivante s'il ne trouve pas les bibliothèques installées.
```
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
```
Pour résoudre cette erreur, indiquez CMake où se trouve le SDK installé (par exemple, le dossier généré suite à l'installation du SDK ([Windows](setup-windows.md), [Linux/macOS](setup-linux.md)). Insérez les commandes suivantes `find_package()` dans votre `CMakeLists.txt` fichier avant votre premier appel. Consultez [Création d'une application simple à l'aide du AWS SDK pour C\$1\$1](build-cmake.md) pour obtenir un exemple.
```
#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()
```
Cette solution ne concerne que la version 1.8 du SDK car ces dépendances sont gérées différemment dans les versions ultérieures. La version 1.9 résout ces problèmes en introduisant une couche intermédiaire entre les `aws-c-*` bibliothèques `aws-sdk-cpp` et. Cette nouvelle couche est appelée `aws-crt-cpp` et est un sous-module git du SDK for C\$1\$1. `aws-crt-cpp`possède également les `aws-c-*` bibliothèques (y compris `aws-c-common``aws-checksums`,` aws-c-event-stream`,, etc.) en tant que sous-modules git. Cela permet au SDK pour C\$1\$1 d'obtenir toutes les bibliothèques CRT de manière récursive et d'améliorer le processus de construction.
## CMake Erreur : Impossible de trouver le fichier de chargement
CMake génère l'erreur suivante s'il ne trouve pas les bibliothèques installées.
```
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
```
Pour résoudre cette erreur, demandez CMake de créer des bibliothèques partagées. Avant votre premier appel, insérez la commande suivante `find_package()` dans votre `CMakeLists.txt` fichier. Consultez [Création d'une application simple à l'aide du AWS SDK pour C\$1\$1](build-cmake.md) pour obtenir un exemple.
```
set(BUILD_SHARED_LIBS ON CACHE STRING "Link to shared libraries by default.")
```
## Erreur d'exécution : impossible de continuer car `aws-*.dll` introuvable
CMake génère une erreur similaire à la suivante s'il ne trouve pas la DLL requise.
```
The code execution cannot proceed because aws-cpp-sdk-[dynamodb].dll was not found. Reinstalling the program may fix this problem.
```
Cette erreur se produit car les bibliothèques ou les exécutables requis pour le SDK for C\$1\$1 ne sont pas disponibles dans le même dossier que les exécutables de votre application. Pour résoudre cette erreur, copiez le résultat de compilation du SDK dans votre emplacement exécutable. Le nom de fichier DLL spécifique de l'erreur varie en fonction des AWS services que vous utilisez. Procédez de l'*une* des manières suivantes :
+ Copiez le contenu du `/bin` dossier d' AWS SDK pour C\$1\$1 installation dans le dossier de compilation de votre application.
+ Dans votre `CMakeLists.txt` fichier, utilisez la macro AWSSDK\$1CPY \$1DYN\$1LIBS pour les copier pour vous.
Ajoutez un appel à l'un `AWSSDK_CPY_DYN_LIBS(SERVICE_LIST "" ${CMAKE_CURRENT_BINARY_DIR})` ou `AWSSDK_CPY_DYN_LIBS(SERVICE_LIST "" ${CMAKE_CURRENT_BINARY_DIR}/${CMAKE_BUILD_TYPE})` à l'autre `CMakeLists.txt` fichier pour utiliser cette macro pour effectuer la copie à votre place. Consultez [Création d'une application simple à l'aide du AWS SDK pour C\$1\$1](build-cmake.md) pour obtenir un exemple.
Choisissez le chemin de copie adapté à votre environnement de génération. La création via la ligne de commande place souvent la sortie de génération dans un sous-dossier (`/Debug`), mais ce n'est pas IDEs souvent le cas de Visual Studio et d'autres. Vérifiez où se trouvent vos exécutables de sortie et assurez-vous que la macro est copiée à cet emplacement. Lorsque vous apportez ce type de modifications, il est recommandé de supprimer le contenu du répertoire de sortie de votre build afin d'obtenir un point de départ propre pour la prochaine génération.