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

# Ottenere AWS SDK per C\$1\$1 il codice sorgente
<a name="sdk-from-source"></a>

Puoi utilizzare il codice fornito AWS SDK per C\$1\$1 dal tuo codice creando prima l'SDK dal codice sorgente e poi installandolo localmente. 


**Panoramica del processo**  

| Processo generale  | Processo dettagliato | 
| --- | --- | 
|  [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/sdk-for-cpp/v1/developer-guide/sdk-from-source.html) |  Per prima cosa crea l'SDK dal codice sorgente e installalo.  [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/sdk-for-cpp/v1/developer-guide/sdk-from-source.html) | 
|  [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/sdk-for-cpp/v1/developer-guide/sdk-from-source.html) |  Quindi sviluppa la tua applicazione utilizzando l'SDK.  [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/sdk-for-cpp/v1/developer-guide/sdk-from-source.html)  | 

# Creazione di AWS SDK per C\$1\$1 su Windows
<a name="setup-windows"></a>

Per configurare il AWS SDK per C\$1\$1, puoi creare tu stesso l'SDK direttamente dal codice sorgente o scaricare le librerie utilizzando un gestore di pacchetti.



Il codice sorgente SDK è suddiviso in singoli pacchetti per servizio. L'installazione dell'intero SDK può richiedere fino a un'ora. L'installazione solo del sottoinsieme specifico di servizi utilizzato dal programma riduce i tempi di installazione e riduce anche le dimensioni del disco. Per scegliere quali servizi installare, è necessario conoscere il nome del pacchetto di ogni servizio utilizzato dal programma. Puoi vedere l'elenco delle directory dei pacchetti su [https://github.com/aws/aws-sdk-cpp](https://github.com/aws/aws-sdk-cpp)on GitHub. Il nome del pacchetto è il suffisso del nome della directory del servizio. 

```
aws-sdk-cpp\aws-cpp-sdk-<packageName>   # Repo directory name and packageName
aws-sdk-cpp\aws-cpp-sdk-s3              # Example: Package name is s3
```

## Prerequisiti
<a name="prerequisites"></a>

Sono necessari almeno 4 GB di RAM per creare alcuni dei AWS client più grandi. L'SDK potrebbe non riuscire a creare sui tipi di istanze Amazon EC2 t2.micro*,* t2.small e altri *tipi* di istanze di piccole dimensioni a causa della memoria insufficiente.

Per utilizzare il AWS SDK per C\$1\$1, è necessario uno dei seguenti:
+ Microsoft Visual Studio 2015 o versione successiva, 
+  GNU Compiler Collection (GCC) 4.9 o versione successiva, oppure
+  Clang 3.3 o versione successiva.

## Creazione dell'SDK per Windows con curl
<a name="build-curl-id"></a>

In Windows, l'SDK è costruito con [WinHTTP](https://msdn.microsoft.com/en-us/library/windows/desktop/aa382925%28v=vs.85%29.aspx) come client HTTP predefinito. Tuttavia, WinHTTP 1.0 non supporta lo streaming bidirezionale HTTP/2, richiesto per alcuni come Servizi AWS Amazon Transcribe e Amazon Lex. Pertanto, a volte è necessario creare il supporto curl con l'SDK. Per visualizzare tutte le opzioni di download di curl disponibili, consulta [curl](https://curl.se/download.html) Releases and Downloads. Un metodo per creare l'SDK con supporto curl è il seguente:

**Per creare l'SDK con supporto per la libreria curl incluso**

1. Vai a [curl per Windows](https://curl.se/windows/) e scarica il pacchetto binario curl per Microsoft Windows. 

1. Decomprimi il pacchetto in una cartella sul tuo computer, ad esempio. `C:\curl` 

1. Vai ai [certificati CA estratti da Mozilla](http://curl.haxx.se/docs/caextract.html) e scarica il file. `cacert.pem` Questo file Privacy Enhanced Mail (PEM) contiene un pacchetto di certificati digitali validi che vengono utilizzati per verificare l'autenticità di siti Web sicuri. I certificati sono distribuiti da società di autorità di certificazione (CA) come GlobalSign Verisign. 

1. Sposta il `cacert.pem` file nella `bin` sottocartella che hai decompresso nel passaggio precedente, ad esempio. `C:\curl\bin` Rinomina il file come. `curl-ca-bundle.crt` 

Inoltre, Microsoft Build Engine (MSBuild) deve essere in grado di individuare il curl `dll` nella procedura seguente. Pertanto, è necessario aggiungere il percorso della `bin` cartella curl alla variabile di `PATH` ambiente Windows, ad esempio. `set PATH=%PATH%;C:\curl\bin` È necessario aggiungerlo ogni volta che si apre un nuovo prompt dei comandi per creare l'SDK. In alternativa, puoi impostare la variabile di ambiente a livello globale nelle impostazioni di sistema di Windows in modo che l'impostazione venga memorizzata.

Quando *crei l'SDK dal codice sorgente* nella procedura che segue, consulta il Passaggio 5 (Generazione dei file di build) per la sintassi dei comandi richiesta per inserire curl nel tuo SDK. 

Quando scrivi il codice, devi impostare `caFile` la posizione del [Configurazione dell' AWS SDK per i client del servizio C\$1\$1 nel codice](client-config.md) file del certificato. Per un esempio di utilizzo di Amazon Transcribe, [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)consulta il *Code Examples AWS Repository* su. GitHub

## Creazione dell'SDK dal codice sorgente
<a name="setup-windows-from-source"></a>

Puoi creare l'SDK dal codice sorgente utilizzando strumenti da riga di comando. Utilizzando questo metodo, puoi personalizzare la build dell'SDK. Per informazioni sulle opzioni disponibili, consulta [CMake Parametri](cmake-params.md). Esistono tre passaggi principali. Innanzitutto, crei i file utilizzando CMake. In secondo luogo, li usi MSBuild per creare i binari SDK che funzionano con il tuo sistema operativo e creare la toolchain. In terzo luogo, installate o copiate i file binari nella posizione corretta sulla macchina di sviluppo.

**Per creare l'SDK dal codice sorgente**

1. Installa [CMake](https://cmake.org/)(versione minima 3.13) e gli strumenti di compilazione pertinenti per la tua piattaforma. Si consiglia di aggiungerlo `cmake` al tuo`PATH`. Per verificare la tua versione di CMake, apri il prompt dei comandi ed esegui il comando **cmake --version**

1. In un prompt dei comandi, accedi alla cartella in cui desideri archiviare l'SDK.

1. Scarica il codice sorgente più recente.

   La versione 1.11 utilizza i sottomoduli git per racchiudere le dipendenze esterne. Ciò include le [librerie CRT](https://docs.aws.amazon.com/sdkref/latest/guide/common-runtime.html) descritte nella *AWS SDKs and* Tools Reference Guide.

   Scarica o clona il codice sorgente dell'SDK da: [https://github.com/aws/aws-sdk-cpp](https://github.com/aws/aws-sdk-cpp) GitHub
   + Clona con Git: HTTPS

     ```
     git clone --recurse-submodules https://github.com/aws/aws-sdk-cpp
     ```
   + Clona con Git: SSH

     ```
     git clone --recurse-submodules git@github.com:aws/aws-sdk-cpp.git
     ```

1. Ti consigliamo di archiviare i file di build generati all'esterno della directory dei sorgenti dell'SDK. Crea una nuova directory in cui archiviare i file di build e accedi a quella cartella.

   ```
   mkdir sdk_build
   cd sdk_build
   ```

1. Genera i file di build eseguendo`cmake`. Specificare sulla `cmake` riga di comando se creare una versione di *Debug* o *Release*. `Debug`Durante questa procedura, scegliete di eseguire una configurazione di debug del codice dell'applicazione. `Release`Durante questa procedura, scegliete di eseguire una configurazione di rilascio del codice dell'applicazione. Per Windows, la posizione di installazione dell'SDK è in genere`\Program Files (x86)\aws-cpp-sdk-all\`. Sintassi del comando: 

   `{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}`

   Per altri modi per modificare l'output della build, consulta [CMakeParametri](cmake-params.md).

   Per generare i file di build, effettuate una delle seguenti operazioni:
   + **Genera file di build (tutti Servizi AWS)***: per creare l'intero SDK, esegui cmake, specificando se creare una versione di *Debug* o Release.* Esempio:

     ```
     cmake "..\aws-sdk-cpp" -DCMAKE_BUILD_TYPE=Debug -DCMAKE_PREFIX_PATH="C:\Program Files (x86)\aws-cpp-sdk-all"
     ```

     
   + **Genera file di build (sottoinsieme Servizi AWS)**: per creare solo un particolare servizio o uno o più pacchetti di servizi per l'SDK, aggiungi il CMake [BUILD\$1ONLY](cmake-params.md#cmake-build-only) parametro, con i nomi dei servizi separati da punto e virgola. L'esempio seguente crea solo il pacchetto di servizi Amazon S3:

     ```
     cmake ..\aws-sdk-cpp -DCMAKE_BUILD_TYPE=Debug -DBUILD_ONLY="s3" -DCMAKE_PREFIX_PATH="C:\Program Files (x86)\aws-cpp-sdk-all"
     ```
   + **Genera file di build (con curl)**: dopo aver completato i prerequisiti curl, sono necessarie tre opzioni aggiuntive della riga di comando cmake per includere il supporto curl nell'SDK:, e. [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) Esempio: 

     ```
     cmake ..\aws-sdk-cpp -DCMAKE_BUILD_TYPE=Debug -DFORCE_CURL=ON -DCURL_INCLUDE_DIR='C:/curl/include'
           -DCURL_LIBRARY='C:/curl/lib/libcurl.dll.a' -DCMAKE_PREFIX_PATH="C:\Program Files (x86)\aws-cpp-sdk-all"
     ```
**Nota**  
Se ricevi un errore Impossibile creare librerie di terze parti, controlla la tua versione di by running. CMake **cmake --version** È necessario utilizzare la versione CMake minima 3.13. 

1. Crea i file binari dell'SDK. Se stai creando l'intero SDK, questo passaggio può richiedere un'ora o più. Sintassi del comando: 

   `{path to cmake if not in PATH} --build . --config=[Debug | Release]`

   ```
   cmake --build . --config=Debug
   ```
**Nota**  
Se si verifica l'errore L'esecuzione del codice non può procedere... dll not found. La reinstallazione del programma può risolvere questo problema.» , riprova a `cmake` eseguire il comando.

1. Apri un prompt dei comandi con privilegi di **amministratore** per installare l'SDK nella posizione specificata in precedenza utilizzando il parametro. `CMAKE_PREFIX_PATH` Sintassi del comando: 

   `{path to cmake if not in PATH} --install . --config=[Debug | Release]`

   ```
   cmake --install . --config=Debug
   ```

## Creazione per Android su Windows
<a name="building-for-android"></a>

Per creare per Android, aggiungilo `-DTARGET_ARCH=ANDROID` alla `cmake` riga di comando. AWS SDK per C\$1\$1 Include un file CMake toolchain che include ciò di cui hai bisogno facendo riferimento alle variabili di ambiente appropriate ()`ANDROID_NDK`.

Per creare l'SDK for Android su Windows, devi `cmake` eseguirlo da un prompt dei comandi per sviluppatori di Visual Studio (2015 o successivo). Avrai anche bisogno che NMAKE [NMAKE](https://docs.microsoft.com/en-us/cpp/build/reference/nmake-reference?view=msvc-160) sia installato e che i comandi **`git`**siano presenti nel tuo percorso. **`patch`** Se hai installato git su un sistema Windows, molto probabilmente lo troverai **`patch`**in una directory di pari livello (). `.../Git/usr/bin/` Una volta verificati questi requisiti, la `cmake` riga di comando cambierà leggermente per utilizzare NMAKE.

```
cmake -G "NMake Makefiles" `-DTARGET_ARCH=ANDROID` <other options> ..
```

NMAKE viene compilato in serie. Per creare più rapidamente, ti consigliamo di installare JOM in alternativa a NMAKE e quindi modificare l'invocazione come segue: `cmake`

```
cmake -G "NMake Makefiles JOM" `-DTARGET_ARCH=ANDROID` <other options> ..
```

Per un'applicazione di esempio, vedi [Configurazione](https://aws.amazon.com/blogs/developer/setting-up-an-android-application-with-aws-sdk-for-c/) di un'applicazione Android con AWS SDK per C\$1\$1

# Creazione di AWS SDK per C\$1\$1 su Linux/macOS
<a name="setup-linux"></a>

Per configurare il AWS SDK per C\$1\$1, puoi creare tu stesso l'SDK direttamente dal sorgente o scaricare le librerie usando un gestore di pacchetti.



Il codice sorgente SDK è suddiviso in singoli pacchetti per servizio. L'installazione dell'intero SDK può richiedere fino a un'ora. L'installazione solo del sottoinsieme specifico di servizi utilizzato dal programma riduce i tempi di installazione e riduce anche le dimensioni del disco. Per scegliere quali servizi installare, è necessario conoscere il nome del pacchetto di ogni servizio utilizzato dal programma. Puoi vedere l'elenco delle directory dei pacchetti su [https://github.com/aws/aws-sdk-cpp](https://github.com/aws/aws-sdk-cpp)on GitHub. Il nome del pacchetto è il suffisso del nome della directory del servizio. 

```
aws-sdk-cpp\aws-cpp-sdk-<packageName>   # Repo directory name and packageName
aws-sdk-cpp\aws-cpp-sdk-s3              # Example: Package name is s3
```

## Prerequisiti
<a name="prerequisites"></a>

Sono necessari almeno 4 GB di RAM per creare alcuni dei AWS client più grandi. L'SDK potrebbe non riuscire a creare sui tipi di istanze Amazon EC2 t2.micro*,* t2.small e altri *tipi* di istanze di piccole dimensioni a causa della memoria insufficiente.

Per utilizzare il AWS SDK per C\$1\$1, è necessario uno dei seguenti:
+  GNU Compiler Collection (GCC) 4.9 o versione successiva, oppure
+  Clang 3.3 o versione successiva.

## Requisiti aggiuntivi per i sistemi Linux
<a name="additional-requirements-for-linux-systems"></a>

È necessario disporre dei file di intestazione (`-dev`pacchetti) per`libcurl`,, e `libopenssl``libuuid`, `zlib` facoltativamente, `libpulse` per il supporto di Amazon Polly. Puoi trovare i pacchetti utilizzando il gestore di pacchetti del tuo sistema.

**Per installare i pacchetti su sistemi basati su *Debian/Ubuntu***
+ 

  ```
  sudo apt-get install libcurl4-openssl-dev libssl-dev uuid-dev zlib1g-dev libpulse-dev
  ```

**Per installare i pacchetti su *sistemi Linux/Redhat/Fedora/CentOS basati su Amazon***
+ 

  ```
  sudo yum install libcurl-devel openssl-devel libuuid-devel pulseaudio-libs-devel
  ```

## Creazione dell'SDK dal codice sorgente
<a name="setup-linux-from-source"></a>

È possibile creare l'SDK dal codice sorgente utilizzando strumenti da riga di comando in alternativa all'utilizzo di vcpkg. Utilizzando questo metodo, puoi personalizzare la build dell'SDK. Per informazioni sulle opzioni disponibili, consulta [CMake Parametri](cmake-params.md).

**Per creare l'SDK dal codice sorgente**

1. Installa [CMake](https://cmake.org/)(versione minima 3.13) e gli strumenti di compilazione pertinenti per la tua piattaforma. Si consiglia di aggiungerlo `cmake` al tuo`PATH`. Per verificare la tua versione di CMake, apri il prompt dei comandi ed esegui il comando **cmake --version**

1. In un prompt dei comandi, accedi alla cartella in cui desideri archiviare l'SDK.

1. Scarica il codice sorgente più recente.

   La versione 1.11 utilizza i sottomoduli git per racchiudere le dipendenze esterne. Ciò include le [librerie CRT](https://docs.aws.amazon.com/sdkref/latest/guide/common-runtime.html) descritte nella *AWS SDKs and* Tools Reference Guide.

   Scarica o clona il codice sorgente dell'SDK da: [https://github.com/aws/aws-sdk-cpp](https://github.com/aws/aws-sdk-cpp) GitHub
   + Clona con Git: HTTPS

     ```
     git clone --recurse-submodules https://github.com/aws/aws-sdk-cpp
     ```
   + Clona con Git: SSH

     ```
     git clone --recurse-submodules git@github.com:aws/aws-sdk-cpp.git
     ```

1. Ti consigliamo di archiviare i file di build generati all'esterno della directory dei sorgenti dell'SDK. Crea una nuova directory in cui archiviare i file di build e accedi a quella cartella.

   ```
   mkdir sdk_build
   cd sdk_build
   ```

1. Genera i file di build eseguendo`cmake`. Specificare sulla `cmake` riga di comando se creare una versione di *Debug* o *Release*. `Debug`Durante questa procedura, scegliete di eseguire una configurazione di debug del codice dell'applicazione. `Release`Durante questa procedura, scegliete di eseguire una configurazione di rilascio del codice dell'applicazione. Sintassi del comando: 

   `{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}`

   Per altri modi per modificare l'output della build, consulta [CMakeParametri](cmake-params.md).
**Nota**  
Quando crei su un Mac con un filesystem senza distinzione tra maiuscole e minuscole, controlla l'output del `pwd` comando nella directory in cui esegui la build. Assicurati che l'`pwd`output utilizzi una combinazione di maiuscole e minuscole per i nomi di directory come e. `/Users` `Documents`

   Per generare i file di build, effettuate una delle seguenti operazioni:
   + **Genera file di build (tutti Servizi AWS)***: per creare l'intero SDK, esegui cmake, specificando se creare una versione di *Debug* o Release.* Esempio:

     ```
     cmake ../aws-sdk-cpp -DCMAKE_BUILD_TYPE=Debug -DCMAKE_PREFIX_PATH=/usr/local/ -DCMAKE_INSTALL_PREFIX=/usr/local/
     ```

     
   + **Genera file di build (sottoinsieme Servizi AWS)**: per creare solo un particolare servizio o uno o più pacchetti di servizi per l'SDK, aggiungi il CMake [BUILD\$1ONLY](cmake-params.md#cmake-build-only) parametro, con i nomi dei servizi separati da punto e virgola. L'esempio seguente crea solo il pacchetto di servizi Amazon S3:

     ```
     cmake ../aws-sdk-cpp -DCMAKE_BUILD_TYPE=Debug -DCMAKE_PREFIX_PATH=/usr/local/ -DCMAKE_INSTALL_PREFIX=/usr/local/ -DBUILD_ONLY="s3"
     ```
**Nota**  
Se ricevi un errore Impossibile creare librerie di terze parti, controlla la tua versione di CMake by running. **cmake --version** È necessario utilizzare la versione CMake minima 3.13. 

1. Crea i file binari dell'SDK. Se stai creando l'intero SDK, l'operazione può richiedere un'ora o più. 

   ```
   cmake --build . --config=Debug
   ```

1. Installa l'SDK. Potrebbe essere necessario aumentare i privilegi a seconda della posizione in cui hai scelto di eseguire l'installazione.

   ```
   cmake --install . --config=Debug
   ```

## Sviluppo per Android su Linux
<a name="building-for-android"></a>

Per creare per Android, aggiungilo `-DTARGET_ARCH=ANDROID` alla `cmake` riga di comando. AWS SDK per C\$1\$1 Include un file CMake toolchain che include ciò di cui hai bisogno facendo riferimento alle variabili di ambiente appropriate ()`ANDROID_NDK`. Per un'applicazione di esempio, vedi [Configurazione di un'applicazione Android con AWS SDK per C\$1\$1](https://aws.amazon.com/blogs/developer/setting-up-an-android-application-with-aws-sdk-for-c/)

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