As traduções são geradas por tradução automática. Em caso de conflito entre o conteúdo da tradução e da versão original em inglês, a versão em inglês prevalecerá.

# Obtendo o AWS SDK para C\$1\$1 do código-fonte
<a name="sdk-from-source"></a>

Você pode usar o AWS SDK para C\$1\$1 do seu código criando primeiro o SDK a partir do código-fonte e depois instalando-o localmente. 


**Visão geral do processo**  

| Processo geral  | Detalhes do processo | 
| --- | --- | 
|  [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/sdk-for-cpp/v1/developer-guide/sdk-from-source.html) |  Primeiro compile o SDK do código-fonte e instale-o.  [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/sdk-for-cpp/v1/developer-guide/sdk-from-source.html) | 
|  [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/sdk-for-cpp/v1/developer-guide/sdk-from-source.html) |  Depois, desenvolva sua própria aplicação usando o SDK.  [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/sdk-for-cpp/v1/developer-guide/sdk-from-source.html)  | 

# Construindo o AWS SDK para C\$1\$1 no Windows
<a name="setup-windows"></a>

Para configurar o AWS SDK para C\$1\$1, você mesmo pode criar o SDK diretamente da fonte ou baixar as bibliotecas usando um gerenciador de pacotes.



O código-fonte do SDK é separado em pacotes individuais por serviço. A instalação do SDK completo pode levar até uma hora. Instalar somente o subconjunto específico de serviços que seu programa usa diminui o tempo de instalação e também reduz o tamanho do disco. Para escolher quais serviços instalar, você precisa saber o nome do pacote de cada serviço que seu programa usa. Você pode ver a lista de diretórios de pacotes em [https://github.com/aws/aws-sdk-cpp](https://github.com/aws/aws-sdk-cpp)on. GitHub O nome do pacote é o sufixo do nome do diretório do serviço. 

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

## Pré-requisitos
<a name="prerequisites"></a>

Você precisa de um mínimo de 4 GB de RAM para criar alguns dos maiores AWS clientes. O SDK pode falhar na criação dos tipos de instância *t2.micro*, *t2.small* e outros tipos de instâncias pequenas do Amazon EC2 devido à memória insuficiente.

Para usar o AWS SDK para C\$1\$1, você precisa de um dos seguintes:
+ Microsoft Visual Studio 2015 ou posterior, 
+  GNU Compiler Collection (GCC) 4.9 ou posterior, ou
+  Clang 3.3 ou posterior.

## Compilar o SDK para Windows com curl
<a name="build-curl-id"></a>

No Windows, o SDK é compilado com [WinHTTP](https://msdn.microsoft.com/en-us/library/windows/desktop/aa382925%28v=vs.85%29.aspx) como cliente HTTP padrão. No entanto, o WinHTTP 1.0 não oferece suporte ao streaming bidirecional HTTP/2, o que é necessário para alguns, como o Amazon Transcribe e o Serviços da AWS Amazon Lex. Portanto, às vezes é necessário criar suporte ao curl com o SDK. Para ver todas as opções de download de curl disponíveis, consulte [Versões e downloads do curl](https://curl.se/download.html). Veja a seguir um método para compilar o SDK com suporte a curl:

**Para compilar o SDK com suporte à biblioteca curl incluído**

1. Navegue até [curl para Windows](https://curl.se/windows/) e baixe o pacote binário curl para Microsoft Windows. 

1. Descompacte o pacote em uma pasta no computador, por exemplo, `C:\curl`. 

1. Navegue até [Certificados CA extraídos do Mozilla](http://curl.haxx.se/docs/caextract.html) e baixe o arquivo `cacert.pem`. Esse arquivo Privacy Enhanced Mail (PEM) contém um pacote de certificados digitais válidos que são usados para verificar a autenticidade de sites seguros. Os certificados são distribuídos por empresas de autoridade de certificação (CA), como GlobalSign a Verisign. 

1. Mova o arquivo `cacert.pem` para a subpasta `bin` que você descompactou em uma etapa anterior, por exemplo, `C:\curl\bin`. Renomeie o arquivo para `curl-ca-bundle.crt`. 

Além disso, o Microsoft Build Engine (MSBuild) deve ser capaz de localizar a curva `dll` no procedimento a seguir. Portanto, você deve adicionar o caminho da pasta `bin` do curl à sua variável de ambiente `PATH` do Windows, por exemplo, `set PATH=%PATH%;C:\curl\bin`. Você deve adicionar isso sempre que abrir um novo prompt de comando para compilar o SDK. Você também pode definir a variável de ambiente globalmente nas configurações do sistema Windows para que a configuração seja lembrada.

Ao *compilar o SDK do código-fonte* no procedimento a seguir, consulte a Etapa 5 (Gerar arquivos de compilação) para ver a sintaxe de comando necessária para criar o curl em seu SDK. 

Ao escrever seu código, você deve definir `caFile` no [Configurar clientes de serviço no código do AWS SDK para C\$1\$1 no código](client-config.md) como o local do seu arquivo de certificado. Para ver um exemplo usando o 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)consulte no Repositório de exemplos de *código* em AWS . GitHub

## Compilar o SDK do código-fonte
<a name="setup-windows-from-source"></a>

Você pode compilar o SDK do código-fonte usando ferramentas de linha de comandos. Usando esse método, você pode personalizar sua compilação do SDK. Para obter informações sobre as opções disponíveis, consulte [CMake Parâmetros](cmake-params.md). Veja as três etapas principais: Primeiro, você cria os arquivos usando CMake. Em segundo lugar, você usa MSBuild para criar os binários do SDK que funcionam com seu sistema operacional e criar uma cadeia de ferramentas. Em terceiro lugar, você vai instalar ou copiar os binários no local correto na máquina de desenvolvimento.

**Como compilar o SDK do código-fonte**

1. Instale [CMake](https://cmake.org/)(versão mínima 3.13) e as ferramentas de construção relevantes para sua plataforma. É recomendável adicionar o `cmake` ao seu `PATH`. Para verificar sua versão do CMake, abra um prompt de comando e execute o comando **cmake --version**

1. Em um prompt de comando, navegue até uma pasta onde você deseja armazenar o SDK.

1. Acesse o código-fonte mais recente.

   A versão 1.11 usa submódulos git para agrupar dependências externas. Isso inclui as [bibliotecas CRT](https://docs.aws.amazon.com/sdkref/latest/guide/common-runtime.html) descritas no *Guia de referência de ferramentas AWS SDKs e ferramentas*.

   Baixe ou clone a fonte do SDK a partir de [https://github.com/aws/aws-sdk-cpp](https://github.com/aws/aws-sdk-cpp): GitHub
   + Clone com Git: HTTPS

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

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

1. Recomendamos que você armazene os arquivos de compilação gerados fora do diretório do código-fonte do SDK. Crie outro diretório para armazenar os arquivos de compilação, e navegue até essa pasta.

   ```
   mkdir sdk_build
   cd sdk_build
   ```

1. Gere os arquivos de compilação executando `cmake`. Especifique na linha de comandos `cmake` se deseja criar uma versão de *depuração* ou *lançamento*. Escolha `Debug` em todo esse procedimento para executar uma configuração de depuração do código da sua aplicação. Escolha `Release` em todo esse procedimento para executar uma configuração de lançamento do código da sua aplicação. Para Windows, o local de instalação do SDK normalmente é `\Program Files (x86)\aws-cpp-sdk-all\`. Sintaxe de 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}`

   Para obter mais maneiras de modificar a saída da compilação, consulte [CMakeParâmetros](cmake-params.md).

   Para gerar os arquivos de compilação, siga um destes procedimentos:
   + **Gere arquivos de compilação (todos Serviços da AWS)***: Para criar o SDK inteiro, execute cmake, especificando se deseja criar uma versão de *depuração* ou lançamento.* Por exemplo:

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

     
   + **Gere arquivos de compilação (subconjunto Serviços da AWS)**: para criar somente um serviço ou pacotes de serviços específicos para o SDK, adicione o CMake [BUILD\$1ONLY](cmake-params.md#cmake-build-only) parâmetro, com os nomes dos serviços separados por ponto e vírgula. O exemplo a seguir compila somente o pacote de serviços do Amazon S3:

     ```
     cmake ..\aws-sdk-cpp -DCMAKE_BUILD_TYPE=Debug -DBUILD_ONLY="s3" -DCMAKE_PREFIX_PATH="C:\Program Files (x86)\aws-cpp-sdk-all"
     ```
   + **Gere arquivos de compilação (com curl)**: depois de concluir os pré-requisitos do curl, três opções adicionais de linha de comandos do cmake são necessárias para incluir o suporte ao curl no SDK: [FORCE\$1CURL](cmake-params.md#cmake-force-curl), [CURL\$1INCLUDE\$1DIR](cmake-params.md#cmake-curl-include-dir) e [CURL\$1LIBRARY](cmake-params.md#cmake-curl-library). Por exemplo: 

     ```
     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 você receber um erro Falha ao criar bibliotecas de terceiros, verifique sua versão do CMake executando**cmake --version**. Você deve usar a versão CMake mínima 3.13. 

1. Compile os binários do SDK. Se você estiver compilando o SDK completo, essa etapa pode levar uma hora ou mais. Sintaxe de comando: 

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

   ```
   cmake --build . --config=Debug
   ```
**nota**  
Se você encontrar o erro A execução do código não pode prosseguir... dll não encontrada. A reinstalação do programa pode resolver esse problema.”, repita o comando `cmake` novamente.

1. Abra um prompt de comando com privilégios de **administrador** para instalar o SDK no local especificado anteriormente usando o parâmetro `CMAKE_PREFIX_PATH`. Sintaxe de comando: 

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

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

## Compilação para Android no Windows
<a name="building-for-android"></a>

Para realizar a compilação para Android, adicione `-DTARGET_ARCH=ANDROID` à sua linha de comandos do `cmake`. AWS SDK para C\$1\$1 Inclui um arquivo CMake de conjunto de ferramentas que inclui o que você precisa referenciando as variáveis de ambiente apropriadas ()`ANDROID_NDK`.

Para compilar o SDK para Android no Windows, você precisa executar o `cmake` por meio de um prompt de comando do desenvolvedor do Visual Studio (2015 ou posterior). Você também precisará do NMAKE [NMAKE](https://docs.microsoft.com/en-us/cpp/build/reference/nmake-reference?view=msvc-160) instalado e dos comandos **`git`** e **`patch`** em seu caminho. Se você tiver o git instalado em um sistema Windows, provavelmente encontrará o **`patch`** em um diretório irmão (`.../Git/usr/bin/`). Depois de verificar esses requisitos, sua linha de comandos do `cmake` mudará um pouco para usar o NMAKE.

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

O NMAKE é compilado em série. Para compilar mais rapidamente, recomendamos que você instale o JOM como alternativa ao NMAKE e, depois, altere a invocação do `cmake` da seguinte forma:

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

Para ver um exemplo de aplicativo, consulte [Configurando um aplicativo Android com AWS SDK para C\$1\$1](https://aws.amazon.com/blogs/developer/setting-up-an-android-application-with-aws-sdk-for-c/)

# Construindo o AWS SDK para C\$1\$1 no Linux/macOS
<a name="setup-linux"></a>

Para configurar o AWS SDK para C\$1\$1, você mesmo pode criar o SDK diretamente da fonte ou baixar as bibliotecas usando um gerenciador de pacotes.



O código-fonte do SDK é separado em pacotes individuais por serviço. A instalação do SDK completo pode levar até uma hora. Instalar somente o subconjunto específico de serviços que seu programa usa diminui o tempo de instalação e também reduz o tamanho do disco. Para escolher quais serviços instalar, você precisa saber o nome do pacote de cada serviço que seu programa usa. Você pode ver a lista de diretórios de pacotes em [https://github.com/aws/aws-sdk-cpp](https://github.com/aws/aws-sdk-cpp)on. GitHub O nome do pacote é o sufixo do nome do diretório do serviço. 

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

## Pré-requisitos
<a name="prerequisites"></a>

Você precisa de um mínimo de 4 GB de RAM para criar alguns dos maiores AWS clientes. O SDK pode falhar na criação dos tipos de instância *t2.micro*, *t2.small* e outros tipos de instâncias pequenas do Amazon EC2 devido à memória insuficiente.

Para usar o AWS SDK para C\$1\$1, você precisa de um dos seguintes:
+  GNU Compiler Collection (GCC) 4.9 ou posterior, ou
+  Clang 3.3 ou posterior.

## Requisitos adicionais para sistemas Linux
<a name="additional-requirements-for-linux-systems"></a>

Você precisa ter os arquivos de cabeçalho (pacotes `-dev`) para `libcurl`, `libopenssl`, `libuuid`, `zlib` e, opcionalmente, `libpulse` para suporte do Amazon Polly. Você pode encontrar os pacotes usando o gerenciador de pacotes do sistema.

**Como instalar os pacotes em *sistemas baseados em Debian/Ubuntu***
+ 

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

**Para instalar os pacotes em *sistemas Linux/Redhat/Fedora/CentOS baseados na Amazon***
+ 

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

## Compilar o SDK do código-fonte
<a name="setup-linux-from-source"></a>

Você pode compilar o SDK do código-fonte usando ferramentas de linha de comandos como uma alternativa ao uso do vcpkg. Usando esse método, você pode personalizar sua compilação do SDK. Para obter informações sobre as opções disponíveis, consulte [CMake Parâmetros](cmake-params.md).

**Como compilar o SDK do código-fonte**

1. Instale [CMake](https://cmake.org/)(versão mínima 3.13) e as ferramentas de construção relevantes para sua plataforma. É recomendável adicionar o `cmake` ao seu `PATH`. Para verificar sua versão do CMake, abra um prompt de comando e execute o comando **cmake --version**

1. Em um prompt de comando, navegue até uma pasta onde você deseja armazenar o SDK.

1. Acesse o código-fonte mais recente.

   A versão 1.11 usa submódulos git para agrupar dependências externas. Isso inclui as [bibliotecas CRT](https://docs.aws.amazon.com/sdkref/latest/guide/common-runtime.html) descritas no *Guia de referência de ferramentas AWS SDKs e ferramentas*.

   Baixe ou clone a fonte do SDK a partir de [https://github.com/aws/aws-sdk-cpp](https://github.com/aws/aws-sdk-cpp): GitHub
   + Clone com Git: HTTPS

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

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

1. Recomendamos que você armazene os arquivos de compilação gerados fora do diretório do código-fonte do SDK. Crie outro diretório para armazenar os arquivos de compilação, e navegue até essa pasta.

   ```
   mkdir sdk_build
   cd sdk_build
   ```

1. Gere os arquivos de compilação executando `cmake`. Especifique na linha de comandos `cmake` se deseja criar uma versão de *depuração* ou *lançamento*. Escolha `Debug` em todo esse procedimento para executar uma configuração de depuração do código da sua aplicação. Escolha `Release` em todo esse procedimento para executar uma configuração de lançamento do código da sua aplicação. Sintaxe de 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}`

   Para obter mais maneiras de modificar a saída da compilação, consulte [CMakeParâmetros](cmake-params.md).
**nota**  
Ao compilar em um Mac com um sistema de arquivos que não diferencia maiúsculas de minúsculas, confira a saída do comando `pwd` no diretório onde você executa a compilação. Garanta que a saída `pwd` use letras maiúsculas e minúsculas para nomes de diretórios, como `/Users` e `Documents`.

   Para gerar os arquivos de compilação, siga um destes procedimentos:
   + **Gere arquivos de compilação (todos Serviços da AWS)***: Para criar o SDK inteiro, execute cmake, especificando se deseja criar uma versão de *depuração* ou lançamento.* Por exemplo:

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

     
   + **Gere arquivos de compilação (subconjunto Serviços da AWS)**: para criar somente um serviço ou pacotes de serviços específicos para o SDK, adicione o CMake [BUILD\$1ONLY](cmake-params.md#cmake-build-only) parâmetro, com os nomes dos serviços separados por ponto e vírgula. O exemplo a seguir compila somente o pacote de serviços do 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 você receber um erro Falha ao criar bibliotecas de terceiros, verifique sua versão do CMake executando**cmake --version**. Você deve usar a versão CMake mínima 3.13. 

1. Compile os binários do SDK. Se você estiver compilando o SDK completo, a operação poderá levar uma hora ou mais. 

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

1. Instale o SDK. Talvez seja necessário aumentar os privilégios dependendo do local onde você escolheu instalar.

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

## Compilação para Android no Linux
<a name="building-for-android"></a>

Para realizar a compilação para Android, adicione `-DTARGET_ARCH=ANDROID` à sua linha de comandos do `cmake`. AWS SDK para C\$1\$1 Inclui um arquivo CMake de conjunto de ferramentas que inclui o que você precisa referenciando as variáveis de ambiente apropriadas ()`ANDROID_NDK`. Para ver um exemplo de aplicativo, consulte [Configurando um aplicativo Android com AWS SDK para C\$1\$1](https://aws.amazon.com/blogs/developer/setting-up-an-android-application-with-aws-sdk-for-c/)

# Criação de um aplicativo simples usando o AWS SDK for C\$1\$1
<a name="build-cmake"></a>

 [CMake](https://cmake.org/)é uma ferramenta de compilação que você usa para gerenciar as dependências do seu aplicativo e criar makefiles adequados para a plataforma na qual você está criando. Você pode usar CMake para criar e construir projetos usando AWS SDK para C\$1\$1 o.

Este exemplo relata os buckets do Amazon S3 de sua propriedade. Não é necessário ter um bucket do Amazon S3 em sua conta da AWS neste exemplo, mas será muito mais interessante se você tiver pelo menos um. Consulte [Criar um bucket](https://docs.aws.amazon.com/AmazonS3/latest/userguide/creating-bucket.html) no *Guia do usuário do Amazon Simple Storage Service* se você ainda não tiver um.

## Etapa 1: escrever o código
<a name="setting-up-a-cmake-project"></a>

Este exemplo consiste em uma pasta contendo um arquivo-fonte (`hello_s3.cpp`) e um arquivo `CMakeLists.txt`. O programa usa o Amazon S3 para relatar informações do bucket de armazenamento. Esse código também está disponível no [Repositório AWS de exemplos de código](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code/s3/hello_s3) em GitHub. 

É possível definir várias opções em um arquivo de configuração de compilação `CMakeLists.txt`. Para obter mais informações, consulte o [CMaketutorial](https://cmake.org/cmake-tutorial/) no CMake site. 

**nota**  
Imersão: configuração `CMAKE_PREFIX_PATH`  
Por padrão, o AWS SDK para C\$1\$1 no macOS, Linux, Android e outras plataformas não Windows é instalado `/usr/local` e no Windows é instalado em. `\Program Files (x86)\aws-cpp-sdk-all`  
Quando você instala o AWS SDK nesses locais padrão, encontra CMake automaticamente os recursos necessários. No entanto, se você instalar o AWS SDK em um local personalizado, deverá informar CMake onde encontrar os seguintes recursos resultantes da criação do SDK:  
`AWSSDKConfig.cmake`: um arquivo de configuração que CMake informa como encontrar e usar as bibliotecas do AWS SDK em seu projeto. Sem esse arquivo, CMake não é possível localizar arquivos de cabeçalho do AWS SDK, vincular às bibliotecas do AWS SDK ou configurar os sinalizadores adequados do compilador.
(para a versão 1.8 e anteriores) A localização das dependências: `aws-c-event-stream`, `aws-c-common` e `aws-checksums`.
Para definir um caminho de instalação personalizado:  

```
cmake -DCMAKE_PREFIX_PATH=/path/to/your/aws-sdk-installation /path/to/project/you/are/building
```
Se você não configurar `CMAKE_PREFIX_PATH` uma instalação personalizada, sua compilação falhará com erros como “Não foi possível encontrar AWSSDK” ao CMake tentar processá-la `find_package(AWSSDK)` em seu`CMakeLists.txt`.

**nota**  
Imersão: bibliotecas do runtime do Windows  
Para executar seu programa, vários DLLs são necessários no local executável do seu programa:`aws-c-common.dll`,,,`aws-c-event-stream.dll`, `aws-checksums.dll``aws-cpp-sdk-core.dll`, bem como qualquer um específico DLLs com base nos componentes do seu programa (este exemplo também é necessário `aws-cpp-sdk-s3` porque ele usa o Amazon S3). A segunda `if` instrução no `CMakeLists.txt` arquivo copia essas bibliotecas do local de instalação para o local do executável para atender a esse requisito. `AWSSDK_CPY_DYN_LIBS`é uma macro definida por AWS SDK para C\$1\$1 que copia os SDKs DLLs do local de instalação para o local executável do seu programa. Se eles não DLLs estiverem no local do executável, ocorrerão exceções de tempo de execução de 'arquivo não encontrado'. Se encontrar esses erros, examine essa parte do arquivo `CMakeLists.txt` para ver as alterações necessárias em seu ambiente exclusivo.

**Como criar a pasta e os arquivos-fonte**

1. Crie um and/or projeto de `hello_s3` diretório para armazenar seus arquivos de origem.
**nota**  
Para concluir este exemplo no Visual Studio: escolha **Criar novo projeto** e, em seguida, escolha **CMake Projeto**. Nomeie o projeto `hello_s3`. Esse nome de projeto é usado no arquivo `CMakeLists.txt`.

1. Dentro dessa pasta, adicione um arquivo `hello_s3.cpp` que inclua o código a seguir, que relata os buckets do Amazon S3 de sua propriedade.

   ```
   #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. Adicione um arquivo `CMakeLists.txt` que especifique o nome, os executáveis, os arquivos-fonte e as bibliotecas vinculadas do seu projeto. 

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

## Etapa 2: criar com CMake
<a name="building-with-cmake"></a>

CMake usa as informações `CMakeLists.txt` para criar um programa executável.

Recomendamos criar a aplicação seguindo as práticas padrão para seu IDE.

**Como compilar a aplicação por meio da linha de comandos**

1. Crie um diretório onde **`cmake`** vai compilar sua aplicação.

   ```
   mkdir my_project_build
   ```

1. Mude para o diretório de compilação e execute **`cmake`** usando o caminho do diretório de origem do seu projeto.

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

1. Depois que o **`cmake`** gerar seu diretório de compilação, você poderá usar **`make`** (ou **`nmake`** no Windows) ou MSBUILD (`msbuild ALL_BUILD.vcxproj` ou `cmake --build . --config=Debug`) para compilar a aplicação.

## Etapa 3: executar
<a name="run-app"></a>

Quando você executa essa aplicação, ela exibe a saída do console que lista o número total de buckets do Amazon S3 e o nome de cada bucket.

Recomendamos executar a aplicação seguindo as práticas padrão para seu IDE.

**nota**  
Lembre-se de fazer login\$1 Se você estiver usando o IAM Identity Center para se autenticar, lembre-se de fazer login usando o AWS CLI `aws sso login` comando.

**Como executar o programa via linha de comandos**

1. Acesse o diretório Debug onde o resultado da compilação foi gerado. 

1. Execute o programa usando o nome do executável.

   ```
   hello_s3
   ```

Para obter exemplos adicionais usando o AWS SDK para C\$1\$1, consulte[Exemplos guiados para chamadas Serviços da AWS usando o AWS SDK para C\$1\$1](programming-services.md).