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à.
# Iniziare con AWS SDK per C\$1\$1
AWS SDK per C\$1\$1 è una libreria open source modulare, multipiattaforma che puoi usare per connetterti ad Amazon Web Services.
Viene AWS SDK per C\$1\$1 utilizzata [CMake](https://cmake.org/)per supportare più piattaforme su più domini, inclusi videogiochi, sistemi, dispositivi mobili e integrati. CMake è uno strumento di compilazione che puoi utilizzare per gestire le dipendenze dell'applicazione e creare makefile adatti alla piattaforma su cui stai costruendo. CMake rimuove le parti della build che non vengono utilizzate per la tua piattaforma o applicazione.
Prima di eseguire il codice per accedere alle AWS risorse, devi stabilire in che modo il codice si autentica con. AWS
+ [Autenticazione con l' AWS utilizzo di AWS SDK for C\$1\$1](credentials.md)
Per utilizzarlo AWS SDK per C\$1\$1 nel codice, procurati gli eseguibili SDK compilando direttamente il codice sorgente SDK o utilizzando un gestore di pacchetti.
+ [Ottenere AWS SDK per C\$1\$1 il codice sorgente](sdk-from-source.md)
+ [Ottenere il AWS SDK per C\$1\$1 file da un gestore di pacchetti](sdk-from-pm.md)
Se riscontri problemi di compilazione riguardanti CMake, consulta. [Risoluzione dei problemi di compilazione di AWS SDK for C\$1\$1](troubleshooting-cmake.md)
# Autenticazione con l' AWS utilizzo di AWS SDK for C\$1\$1
È necessario stabilire in che modo il codice si autentica durante lo sviluppo con AWS . Servizi AWSÈ possibile configurare l'accesso programmatico alle AWS risorse in diversi modi a seconda dell'ambiente e dell' AWS accesso a disposizione. Per le scelte su tutti i metodi di autenticazione principali e le indicazioni sulla configurazione per l'SDK, consulta [Autenticazione e accesso](https://docs.aws.amazon.com/sdkref/latest/guide/access.html) nella Guida di riferimento agli *strumenti AWS SDKs e agli strumenti*.
## Utilizzo delle credenziali della console
Per lo sviluppo locale, consigliamo ai nuovi utenti di utilizzare le credenziali di accesso esistenti alla Console di AWS gestione per l'accesso programmatico ai servizi. AWS Dopo un flusso di autenticazione basato su browser, AWS genera credenziali temporanee che funzionano con strumenti di sviluppo locali come la CLI AWS e. AWS Strumenti per PowerShell AWS SDKs Questa funzionalità semplifica il processo di configurazione e gestione delle credenziali AWS CLI, soprattutto se si preferisce l'autenticazione interattiva alla gestione delle chiavi di accesso a lungo termine.
Se scegli questo metodo, segui le istruzioni per accedere con le credenziali della console utilizzando la AWS CLI. Per maggiori dettagli, vedi [Accesso per lo sviluppo AWS locale utilizzando le credenziali della console](https://docs.aws.amazon.com/cli/latest/userguide/cli-configure-sign-in.html).
Una volta configurata con AWS CLI, [la catena di provider di credenziali predefinita](https://docs.aws.amazon.com/sdk-for-cpp/v1/developer-guide/credproviders.html#credproviders-default-credentials-provider-chain) inizierà automaticamente a utilizzare il token di accesso memorizzato nella cache dalla AWS CLI per effettuare richieste.
## Utilizzo di IAM Identity Center
Questo metodo include l'installazione di AWS CLI per facilitare la configurazione e per accedere regolarmente al portale di accesso. AWS
Se scegli questo metodo, completa la procedura per l'[autenticazione di IAM Identity Center](https://docs.aws.amazon.com/sdkref/latest/guide/access-sso.html) nella *AWS SDKs and Tools Reference Guide*. Successivamente, l'ambiente dovrebbe contenere i seguenti elementi:
+ Il AWS CLI, che viene utilizzato per avviare una sessione del portale di AWS accesso prima di eseguire l'applicazione.
+ Un [AWS`config`file condiviso](https://docs.aws.amazon.com/sdkref/latest/guide/file-format.html) con un `[default]` profilo con un set di valori di configurazione a cui è possibile fare riferimento dall'SDK. Per trovare la posizione di questo file, consulta [Posizione dei file condivisi nella Guida](https://docs.aws.amazon.com/sdkref/latest/guide/file-location.html) di *riferimento agli strumenti AWS SDKs e strumenti*.
+ Il `config` file condiviso imposta l'[https://docs.aws.amazon.com/sdkref/latest/guide/feature-region.html](https://docs.aws.amazon.com/sdkref/latest/guide/feature-region.html)impostazione. Questo imposta l'impostazione predefinita Regione AWS utilizzata dall'SDK per AWS le richieste. Questa regione viene utilizzata per le richieste di servizio SDK che non sono specificate con una regione da utilizzare.
+ L'SDK utilizza la [configurazione del provider di token SSO](https://docs.aws.amazon.com/sdkref/latest/guide/feature-sso-credentials.html#feature-sso-credentials-profile) del profilo per acquisire le credenziali prima di inviare richieste a. AWS Il `sso_role_name` valore, che è un ruolo IAM connesso a un set di autorizzazioni IAM Identity Center, dovrebbe consentire l'accesso ai dati Servizi AWS utilizzati nell'applicazione.
Il seguente `config` file di esempio mostra un profilo predefinito impostato con la configurazione del provider di token SSO. L'`sso_session`impostazione del profilo si riferisce alla [`sso-session`sezione](https://docs.aws.amazon.com/sdkref/latest/guide/file-format.html#section-session) denominata. La `sso-session` sezione contiene le impostazioni per avviare una sessione del portale di AWS accesso.
```
[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
```
AWS SDK per C\$1\$1 Non è necessario aggiungere pacchetti aggiuntivi (come `SSO` e`SSOOIDC`) all'applicazione per utilizzare l'autenticazione IAM Identity Center.
### Avvia una sessione del portale di AWS accesso
Prima di eseguire un'applicazione che consente l'accesso Servizi AWS, è necessaria una sessione attiva del portale di AWS accesso affinché l'SDK utilizzi l'autenticazione IAM Identity Center per risolvere le credenziali. A seconda della durata della sessione configurata, l'accesso alla fine scadrà e l'SDK riscontrerà un errore di autenticazione. Per accedere al portale di AWS accesso, esegui il seguente comando in. AWS CLI
```
aws sso login
```
Poiché disponi di una configurazione predefinita del profilo, non devi chiamare il comando con un'opzione `--profile`. Se la configurazione del provider di token SSO utilizza un profilo denominato, il comando è `aws sso login --profile named-profile`.
Per verificare se hai già una sessione attiva, esegui il AWS CLI comando seguente.
```
aws sts get-caller-identity
```
La risposta a questo comando dovrebbe restituire l'account IAM Identity Center e il set di autorizzazioni configurati nel file `config` condiviso.
**Nota**
Se hai già una sessione attiva del portale di AWS accesso ed esegui`aws sso login`, non ti verrà richiesto di fornire credenziali.
La procedura di accesso potrebbe richiedere all'utente di consentire l' AWS CLI accesso ai dati. Poiché AWS CLI è basato sull'SDK per Python, i messaggi di autorizzazione possono contenere variazioni del `botocore` nome.
## Ulteriori informazioni di autenticazione
Utenti umani, noti anche come *identità umane,* sono le persone, gli amministratori, gli sviluppatori, gli operatori e i consumatori delle tue applicazioni. Devono avere un'identità per accedere agli AWS ambienti e alle applicazioni dell'utente. Gli utenti umani che fanno parte della tua organizzazione sono noti anche come *identità della forza lavoro, vale* a dire tu, lo sviluppatore. Utilizza credenziali temporanee per l'accesso. AWS Puoi utilizzare un provider di identità per i tuoi utenti umani per fornire l'accesso federato agli AWS account assumendo ruoli che forniscono credenziali temporanee. Per la gestione centralizzata degli accessi, ti consigliamo di utilizzare AWS IAM Identity Center (IAM Identity Center) per gestire l'accesso ai tuoi account e le autorizzazioni all'interno di tali account. Per altre alternative, consulta quanto segue:
+ Per ulteriori informazioni sulle best practice, consulta [Best practice per la sicurezza in IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/best-practices.html) nella *Guida per l'utente di IAM*.
+ Per creare AWS credenziali a breve termine, consulta [Temporary Security Credentials](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_temp.html) nella *IAM User Guide*.
+ *Per ulteriori informazioni su altri fornitori di AWS SDK per C\$1\$1 credenziali, consulta Provider di [credenziali standardizzati nella and Tools Reference](https://docs.aws.amazon.com/sdkref/latest/guide/standardized-credentials.html) Guide AWS SDKs .*
# Ottenere AWS SDK per C\$1\$1 il codice sorgente
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
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- # Repo directory name and packageName
aws-sdk-cpp\aws-cpp-sdk-s3 # Example: Package name is s3
```
## Prerequisiti
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
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
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
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` ..
```
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` ..
```
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
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- # Repo directory name and packageName
aws-sdk-cpp\aws-cpp-sdk-s3 # Example: Package name is s3
```
## Prerequisiti
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
È 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
È 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
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
[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
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
#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. 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
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
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).
# Ottenere il AWS SDK per C\$1\$1 file da un gestore di pacchetti
**Importante**
Se stai usando un gestore di pacchetti come homebrew o vcpkg:
Dopo aver aggiornato l'SDK for C\$1\$1 a una nuova versione, è necessario ricompilare qualsiasi libreria o eseguibile che dipenda dall'SDK.
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- # Repo directory name and packageName
aws-sdk-cpp\aws-cpp-sdk-s3 # Example: Package name is s3
```
## Prerequisiti
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.
------
#### [ Linux/macOS ]
Per utilizzare AWS SDK per C\$1\$1 su Linux/macOS, è necessario uno dei seguenti:
+ GNU Compiler Collection (GCC) 4.9 o versione successiva, oppure
+ Clang 3.3 o versione successiva.
------
#### [ Windows ]
Per utilizzarlo AWS SDK per C\$1\$1 su Windows, è 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.
------
## Scarica l'SDK usando vcpkg
**Importante**
La distribuzione vcpkg disponibile è supportata da collaboratori esterni e non viene fornita tramite. AWS La versione più recente è sempre disponibile tramite l'[installazione](sdk-from-source.md) dal codice sorgente.
[vcpkg](https://github.com/Microsoft/vcpkg) è un gestore di pacchetti aggiornato e mantenuto da collaboratori esterni. Nota che questo gestore di pacchetti non viene fornito tramite AWS e potrebbe non riflettere l'ultima versione disponibile per. AWS SDK per C\$1\$1 C'è un ritardo tra il momento in cui una versione viene rilasciata da AWS e il momento in cui è disponibile tramite un gestore di pacchetti esterno. La versione più recente è sempre disponibile tramite l'[installazione dal codice sorgente](sdk-from-source.md).
È necessario installare [vcpkg](https://github.com/Microsoft/vcpkg) sul proprio sistema.
+ Scaricate e avviate [vcpkg](https://github.com/Microsoft/vcpkg) seguendo le istruzioni del file GitHub Readme di vcpkg, sostituendo le seguenti opzioni quando richiesto:
+
Come parte di queste istruzioni, sei guidato a inserire:
```
.\vcpkg\vcpkg install [packages to install]
```
Per installare l'intero SDK, inserisci `.\vcpkg\vcpkg install "aws-sdk-cpp[*]" --recurse` o indica solo servizi specifici dell'SDK da installare aggiungendo il nome del pacchetto tra parentesi, ad esempio, `.\vcpkg\vcpkg install "aws-sdk-cpp[s3, ec2]" --recurse`
L'output visualizza un messaggio che include i seguenti:
```
CMake projects should use: "-DCMAKE_TOOLCHAIN_FILE=C:/dev/vcpkg/vcpkg/scripts/buildsystems/vcpkg.cmake"
```
+ Copia il `-DCMAKE_TOOLCHAIN_FILE` comando completo per utilizzarlo CMake in seguito. Il file GitHub Readme di vcpkg indica anche dove utilizzarlo per il set di strumenti.
+ Potrebbe anche essere necessario annotare il tipo di configurazione della build che è stato installato tramite vcpkg. L'output della console mostra la configurazione della build e la versione dell'SDK. L'output di esempio seguente indica che la configurazione di build è «x86-windows» e la AWS SDK per C\$1\$1 versione installata è 1.8.
```
The following packages will be built and installed:
aws-sdk-cpp[core,dynamodb,kinesis,s3]:x86-windows -> 1.8.126#6
```
Dopo aver installato AWS SDK per C\$1\$1, è possibile sviluppare la propria applicazione utilizzando l'SDK. L'esempio mostrato in questa sezione [Creazione di un'applicazione semplice](build-cmake.md) riporta i bucket Amazon S3 che possiedi.
# Risoluzione dei problemi di compilazione di AWS SDK for C\$1\$1
Durante la creazione AWS SDK per C\$1\$1 del codice sorgente, potrebbero verificarsi alcuni dei seguenti problemi comuni di compilazione.
**Topics**
+ [
## CMake Errore: impossibile trovare un file di configurazione del pacchetto fornito da "AWSSDK»
](#could-not-find-package)
+ [
## CMake Errore: impossibile trovare il file di caricamento (e utilizzi la versione SDK 1.8)
](#could-not-load-file)
+ [
## CMake Errore: impossibile trovare il file di caricamento
](#could-not-load-file2)
+ [
## Errore di runtime: impossibile procedere perché non `aws-*.dll` è stato trovato
](#dll-was-not-found)
## CMake Errore: impossibile trovare un file di configurazione del pacchetto fornito da "AWSSDK»
CMake genera il seguente errore se non riesce a trovare l'SDK installato.
```
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.
```
Per risolvere questo errore, indica CMake dove trovare l'SDK installato (ad esempio la cartella generata a seguito dell'installazione dell'SDK ([Windows](setup-windows.md), [Linux/macOS](setup-linux.md)). Inserisci il seguente comando prima della prima chiamata a nel tuo file. `find_package()` `CMakeLists.txt` Consulta [Creazione di un'applicazione semplice utilizzando l' AWS SDK for C\$1\$1](build-cmake.md) per un esempio.
```
list(APPEND CMAKE_PREFIX_PATH "C:\\Program Files (x86)\\aws-cpp-sdk-all\\lib\\cmake")
```
## CMake Errore: impossibile trovare il file di caricamento (e utilizzi la versione SDK 1.8)
CMake genera il seguente errore se non riesce a trovare le librerie installate.
```
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
```
Per risolvere questo errore, indica CMake dove trovare l'SDK installato (ad esempio la cartella generata a seguito dell'installazione dell'SDK ([Windows](setup-windows.md), [Linux/macOS](setup-linux.md)). Inserisci i seguenti comandi prima della prima chiamata a nel tuo file. `find_package()` `CMakeLists.txt` Consulta [Creazione di un'applicazione semplice utilizzando l' AWS SDK for C\$1\$1](build-cmake.md) per un esempio.
```
#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()
```
Questa soluzione è disponibile solo per la versione 1.8 dell'SDK perché queste dipendenze vengono gestite in modo diverso nelle versioni successive. La versione 1.9 risolve questi problemi introducendo un livello intermedio tra le librerie e. `aws-sdk-cpp` `aws-c-*` Questo nuovo livello si chiama `aws-crt-cpp` ed è un sottomodulo git dell'SDK for C\$1\$1. `aws-crt-cpp`ha anche le `aws-c-*` librerie (incluse`aws-c-common`, `aws-checksums`` aws-c-event-stream`, ecc.) come propri sottomoduli git. Ciò consente all'SDK for C\$1\$1 di ottenere tutte le librerie CRT in modo ricorsivo e migliora il processo di compilazione.
## CMake Errore: impossibile trovare il file di caricamento
CMake genera il seguente errore se non riesce a trovare le librerie installate.
```
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
```
Per risolvere questo errore, dì di CMake creare librerie condivise. Inserisci il seguente comando prima della prima chiamata a `find_package()` nel tuo `CMakeLists.txt` file. Consulta [Creazione di un'applicazione semplice utilizzando l' AWS SDK for C\$1\$1](build-cmake.md) per un esempio.
```
set(BUILD_SHARED_LIBS ON CACHE STRING "Link to shared libraries by default.")
```
## Errore di runtime: impossibile procedere perché non `aws-*.dll` è stato trovato
CMake genera un errore simile al seguente se non riesce a trovare una DLL richiesta.
```
The code execution cannot proceed because aws-cpp-sdk-[dynamodb].dll was not found. Reinstalling the program may fix this problem.
```
Questo errore si verifica perché le librerie o gli eseguibili richiesti per l'SDK for C\$1\$1 non sono disponibili nella stessa cartella degli eseguibili dell'applicazione. Per risolvere questo errore, copia l'output della build dell'SDK nella posizione dell'eseguibile. Il nome del file DLL specifico dell'errore varia a seconda AWS dei servizi utilizzati. Effettuate *una* delle seguenti operazioni:
+ Copia il contenuto della `/bin` cartella di AWS SDK per C\$1\$1 installazione nella cartella build dell'applicazione.
+ Nel tuo `CMakeLists.txt` file, usa la macro AWSSDK\$1CPY \$1DYN\$1LIBS per copiarli per te.
Aggiungi una chiamata a uno dei due file `AWSSDK_CPY_DYN_LIBS(SERVICE_LIST "" ${CMAKE_CURRENT_BINARY_DIR})` o `AWSSDK_CPY_DYN_LIBS(SERVICE_LIST "" ${CMAKE_CURRENT_BINARY_DIR}/${CMAKE_BUILD_TYPE})` al tuo `CMakeLists.txt` file per utilizzare questa macro per eseguire la copia al posto tuo. Consulta [Creazione di un'applicazione semplice utilizzando l' AWS SDK for C\$1\$1](build-cmake.md) per un esempio.
Scegli il percorso di copia corretto per il tuo ambiente di compilazione. La creazione tramite riga di comando spesso inserisce l'output di compilazione in una sottocartella (`/Debug`), ma Visual Studio e altri IDEs spesso no. Verifica dove si trovano gli eseguibili di output e assicurati che la macro venga copiata in quella posizione. Quando si apportano questi tipi di modifiche, è buona norma eliminare il contenuto della directory di output della build in modo da ottenere un punto di partenza pulito per la build successiva.