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.

# Obtenir AWS SDK pour C\$1\$1 le code source
<a name="sdk-from-source"></a>

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
<a name="setup-windows"></a>

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-<packageName>   # Repo directory name and packageName
aws-sdk-cpp\aws-cpp-sdk-s3              # Example: Package name is s3
```

## Conditions préalables
<a name="prerequisites"></a>

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
<a name="build-curl-id"></a>

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
<a name="setup-windows-from-source"></a>

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
<a name="building-for-android"></a>

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` <other options> ..
```

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` <other options> ..
```

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
<a name="setup-linux"></a>

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-<packageName>   # Repo directory name and packageName
aws-sdk-cpp\aws-cpp-sdk-s3              # Example: Package name is s3
```

## Conditions préalables
<a name="prerequisites"></a>

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
<a name="additional-requirements-for-linux-systems"></a>

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
<a name="setup-linux-from-source"></a>

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
<a name="building-for-android"></a>

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
<a name="build-cmake"></a>

 [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
<a name="setting-up-a-cmake-project"></a>

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

1. 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
<a name="building-with-cmake"></a>

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
<a name="run-app"></a>

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