Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.

# Creazione di un'applicazione semplice utilizzando l' AWS SDK for C\$1\$1
<a name="build-cmake"></a>

 [CMake](https://cmake.org/)è uno strumento di compilazione che usi per gestire le dipendenze dell'applicazione e per creare makefile adatti alla piattaforma su cui stai costruendo. Puoi usarlo CMake per creare e creare progetti usando. AWS SDK per C\$1\$1

Questo esempio riporta i bucket Amazon S3 che possiedi. Per questo esempio non è necessario avere un bucket Amazon S3 nel tuo AWS account, ma sarà molto più interessante se ne hai almeno uno. Se non ne hai già [uno, consulta Create a Bucket](https://docs.aws.amazon.com/AmazonS3/latest/userguide/creating-bucket.html) nella *Guida per l'utente di Amazon Simple Storage Service*.

## Passaggio 1: scrivi il codice
<a name="setting-up-a-cmake-project"></a>

Questo esempio è costituito da una cartella contenente un file sorgente (`hello_s3.cpp`) e un `CMakeLists.txt` file. Il programma utilizza Amazon S3 per riportare le informazioni sui bucket di archiviazione. Questo codice è disponibile anche nel Code [AWS Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code/s3/hello_s3) su. GitHub 

È possibile impostare molte opzioni in un file di configurazione della `CMakeLists.txt` build. Per ulteriori informazioni, consulta il [CMaketutorial](https://cmake.org/cmake-tutorial/) sul CMake sito Web. 

**Nota**  
Deep Dive: Impostazione `CMAKE_PREFIX_PATH`  
Per impostazione predefinita, le AWS SDK per C\$1\$1 piattaforme macOS, Linux, Android e altre piattaforme non Windows vengono installate in `/usr/local` e su Windows. `\Program Files (x86)\aws-cpp-sdk-all`  
Quando installi l' AWS SDK in queste posizioni standard, trova CMake automaticamente le risorse necessarie. Tuttavia, se installi l' AWS SDK in una posizione personalizzata, devi indicare CMake dove trovare le seguenti risorse risultanti dalla creazione dell'SDK:  
`AWSSDKConfig.cmake`: un file di configurazione che spiega CMake come trovare e utilizzare le librerie AWS SDK nel progetto. Senza questo file, CMake non è possibile individuare i file di intestazione AWS SDK, collegarsi alle librerie AWS SDK o impostare i flag appropriati del compilatore.
(per la versione 1.8 e precedenti) La posizione delle dipendenze:,, `aws-c-event-stream` `aws-c-common` `aws-checksums`
Per impostare un percorso di installazione personalizzato:  

```
cmake -DCMAKE_PREFIX_PATH=/path/to/your/aws-sdk-installation /path/to/project/you/are/building
```
Se non hai impostato `CMAKE_PREFIX_PATH` un'installazione personalizzata, la build fallirà con errori come «Impossibile trovare AWSSDK» quando CMake tenta di elaborarla `find_package(AWSSDK)` nella tua`CMakeLists.txt`.

**Nota**  
Deep Dive: librerie di Windows Runtime  
Per eseguire il programma, DLLs ne sono necessari diversi nella posizione eseguibile del programma: `aws-c-common.dll``aws-c-event-stream.dll`,`aws-checksums.dll`,`aws-cpp-sdk-core.dll`,,, oltre a uno specifico DLLs basato sui componenti del programma (anche questo esempio è necessario `aws-cpp-sdk-s3` perché utilizza Amazon S3). La seconda `if` istruzione del `CMakeLists.txt` file copia queste librerie dalla posizione di installazione alla posizione eseguibile per soddisfare questo requisito. `AWSSDK_CPY_DYN_LIBS`è una macro definita da AWS SDK per C\$1\$1 che copia gli SDK DLLs dalla posizione di installazione alla posizione eseguibile del programma. Se questi non si DLLs trovano nella posizione eseguibile, si verificano le eccezioni di runtime del tipo «file non trovato». Se riscontrate questi errori, controllate questa parte del `CMakeLists.txt` file per verificare le modifiche necessarie per il vostro ambiente specifico.

**Per creare la cartella e i file sorgente**

1. Crea un and/or progetto di `hello_s3` directory per contenere i tuoi file sorgente.
**Nota**  
Per completare questo esempio in Visual Studio: scegli **Crea nuovo progetto**, quindi scegli **CMake Progetto**. Assegnare un nome al progetto `hello_s3`. Questo nome di progetto viene utilizzato nel `CMakeLists.txt` file.

1. All'interno di quella cartella, aggiungi un `hello_s3.cpp` file che include il codice seguente, che riporta i bucket Amazon S3 di tua proprietà.

   ```
   #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. Aggiungi un `CMakeLists.txt` file che specifichi il nome, gli eseguibili, i file sorgente e le librerie collegate del progetto. 

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

## Fase 2: Costruisci con CMake
<a name="building-with-cmake"></a>

CMake utilizza le informazioni `CMakeLists.txt` per creare un programma eseguibile.

Ti consigliamo di creare l'applicazione seguendo le pratiche standard per il tuo IDE.

**Per creare l'applicazione dalla riga di comando**

1. Crea una directory in cui **`cmake`**verrà creata la tua applicazione.

   ```
   mkdir my_project_build
   ```

1. Passa alla directory di compilazione ed esegui **`cmake`**utilizzando il percorso della directory dei sorgenti del progetto.

   ```
   cd my_project_build
   cmake ../
   ```

1. Dopo aver **`cmake`**generato la directory di compilazione, è possibile utilizzare **`make`**(o **`nmake`**su Windows) o MSBUILD (`msbuild ALL_BUILD.vcxproj`o`cmake --build . --config=Debug`) per creare l'applicazione.

## Fase 3: Esegui
<a name="run-app"></a>

Quando esegui questa applicazione, visualizza l'output della console che elenca il numero totale di bucket Amazon S3 e il nome di ogni bucket.

Ti consigliamo di eseguire l'applicazione seguendo le pratiche standard per il tuo IDE.

**Nota**  
Ricordati di effettuare l'accesso\$1 Se utilizzi IAM Identity Center per l'autenticazione, ricordati di accedere utilizzando il AWS CLI `aws sso login` comando.

**Per eseguire il programma tramite riga di comando**

1. Passa alla directory Debug in cui è stato generato il risultato della build. 

1. Esegui il programma utilizzando il nome dell'eseguibile.

   ```
   hello_s3
   ```

Per ulteriori esempi di utilizzo di AWS SDK per C\$1\$1, vedere[Esempi guidati per chiamare Servizi AWS utilizzando l' AWS SDK for C\$1\$1](programming-services.md).