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

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