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.

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