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á.
# Começando com o AWS SDK para C\$1\$1
AWS SDK para C\$1\$1 é uma biblioteca modularizada, multiplataforma e de código aberto que você pode usar para se conectar à Amazon Web Services.
Eles AWS SDK para C\$1\$1 usam [CMake](https://cmake.org/)para oferecer suporte a várias plataformas em vários domínios, incluindo videogames, sistemas, dispositivos móveis e incorporados. CMake é uma ferramenta de compilação que você pode usar para gerenciar as dependências do seu aplicativo e criar makefiles adequados para a plataforma na qual você está criando. CMake remove as partes da compilação que não são usadas em sua plataforma ou aplicativo.
Antes de executar o código para acessar AWS os recursos, você deve estabelecer como seu código é autenticado com AWS.
+ [Autenticação com o AWS uso do AWS SDK for C\$1\$1](credentials.md)
Para usar o AWS SDK para C\$1\$1 em seu código, obtenha os executáveis do SDK criando a fonte do SDK diretamente ou usando um gerenciador de pacotes.
+ [Obtendo o AWS SDK para C\$1\$1 do código-fonte](sdk-from-source.md)
+ [Obtendo o AWS SDK para C\$1\$1 de um gerenciador de pacotes](sdk-from-pm.md)
Se você tiver problemas relacionados à compilação CMake, consulte[Solução de problemas de compilação do AWS SDK for C\$1\$1](troubleshooting-cmake.md).
# Autenticação com o AWS uso do AWS SDK for C\$1\$1
Você deve estabelecer como seu código é autenticado AWS ao desenvolver com Serviços da AWS. Você pode configurar o acesso programático aos AWS recursos de maneiras diferentes, dependendo do ambiente e do AWS acesso disponível para você. Para opções sobre todos os métodos principais de autenticação e orientações sobre como configurá-los para o SDK, consulte [Autenticação e acesso](https://docs.aws.amazon.com/sdkref/latest/guide/access.html) no AWS SDKs Guia de *referência de ferramentas*.
## Usando credenciais do console
Para o desenvolvimento local, recomendamos que os novos usuários usem suas credenciais de login do AWS Management Console existentes para acesso programático aos serviços. AWS Depois de um fluxo de autenticação baseado em navegador, AWS gera credenciais temporárias que funcionam em ferramentas de desenvolvimento locais, como a CLI e. AWS Ferramentas da AWS para PowerShell AWS SDKs Esse recurso simplifica o processo de configuração e gerenciamento de credenciais de AWS CLI, especialmente se você preferir a autenticação interativa em vez de gerenciar chaves de acesso de longo prazo.
Se você escolher esse método, siga as instruções para fazer login com as credenciais do console usando a AWS CLI. Consulte [Login para desenvolvimento AWS local usando credenciais do console](https://docs.aws.amazon.com/cli/latest/userguide/cli-configure-sign-in.html) para obter mais detalhes.
Depois de configurada com a AWS CLI, [a cadeia de provedores de credenciais padrão](https://docs.aws.amazon.com/sdk-for-cpp/v1/developer-guide/credproviders.html#credproviders-default-credentials-provider-chain) começará automaticamente a usar o token de login armazenado em cache pela AWS CLI para fazer solicitações.
## Usar o Centro de Identidade do IAM
Esse método inclui a instalação do AWS CLI para facilitar a configuração e entrar regularmente no portal de AWS acesso.
Se você escolher esse método, conclua o procedimento para [autenticação do IAM Identity Center](https://docs.aws.amazon.com/sdkref/latest/guide/access-sso.html) no *Guia de referência de ferramentas AWS SDKs e ferramentas*. Depois disso, seu ambiente deverá conter os seguintes elementos:
+ O AWS CLI, que você usa para iniciar uma sessão do portal de AWS acesso antes de executar seu aplicativo.
+ Um [arquivo AWS`config` compartilhado](https://docs.aws.amazon.com/sdkref/latest/guide/file-format.html) com um perfil de `[default]` com um conjunto de valores de configuração que podem ser referenciados a partir do SDK. Para encontrar a localização desse arquivo, consulte [Localização dos arquivos compartilhados no](https://docs.aws.amazon.com/sdkref/latest/guide/file-location.html) *Guia de referência de ferramentas AWS SDKs e ferramentas*.
+ O arquivo `config` compartilhado define a configuração do [https://docs.aws.amazon.com/sdkref/latest/guide/feature-region.html](https://docs.aws.amazon.com/sdkref/latest/guide/feature-region.html). Isso define o padrão Região da AWS que o SDK usa para AWS solicitações. Essa região é usada para solicitações de serviço do SDK que não são fornecidas com uma Região específica para uso.
+ O SDK usa a [configuração do provedor do token de SSO](https://docs.aws.amazon.com/sdkref/latest/guide/feature-sso-credentials.html#feature-sso-credentials-profile) do perfil para adquirir credenciais antes de enviar solicitações para a AWS. O `sso_role_name` valor, que é uma função do IAM conectada a um conjunto de permissões do IAM Identity Center, deve permitir o acesso ao Serviços da AWS usado em seu aplicativo.
O arquivo `config` de amostra a seguir mostra um perfil padrão configurado com o provedor de token de SSO. A configuração `sso_session` do perfil se refere à [seção do `sso-session`](https://docs.aws.amazon.com/sdkref/latest/guide/file-format.html#section-session). A `sso-session` seção contém configurações para iniciar uma sessão do portal de AWS acesso.
```
[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 para C\$1\$1 Não é necessário adicionar pacotes adicionais (como `SSO` e`SSOOIDC`) ao seu aplicativo para usar a autenticação do IAM Identity Center.
### Iniciar uma sessão do portal de AWS acesso
Antes de executar um aplicativo que acessa Serviços da AWS, você precisa de uma sessão ativa do portal de AWS acesso para que o SDK use a autenticação do IAM Identity Center para resolver as credenciais. Dependendo da duração da sessão configurada, o seu acesso acabará expirando e o SDK encontrará um erro de autenticação. Para entrar no portal de AWS acesso, execute o seguinte comando no AWS CLI.
```
aws sso login
```
Como você tem uma configuração de perfil padrão, não precisa chamar o comando com uma opção `--profile`. Se a configuração do provedor de token de SSO estiver usando um perfil nomeado, o comando será `aws sso login --profile named-profile`.
Para testar se você já tem uma sessão ativa, execute o AWS CLI comando a seguir.
```
aws sts get-caller-identity
```
A resposta a esse comando deve relatar a conta do Centro de Identidade do IAM e o conjunto de permissões configurados no arquivo compartilhado `config`.
**nota**
Se você já tiver uma sessão ativa do portal de AWS acesso e executá-la`aws sso login`, não será necessário fornecer credenciais.
O processo de login pode solicitar que você permita o AWS CLI acesso aos seus dados. Como o AWS CLI é construído sobre o SDK para Python, as mensagens de permissão podem conter variações do `botocore` nome.
## Mais informações de autenticação
Os usuários humanos, também conhecidos como *identidades humanas,* são as pessoas, os administradores, os desenvolvedores, os operadores e os consumidores de suas aplicações. Eles devem ter uma identidade para acessar seus AWS ambientes e aplicativos. Usuários humanos que são membros da sua organização também são conhecidos como *identidades da força de trabalho*, ou seja, você, o desenvolvedor. Use credenciais temporárias ao acessar AWS. Você pode usar um provedor de identidade para seus usuários humanos para fornecer acesso federado às AWS contas assumindo funções que fornecem credenciais temporárias. Para o gerenciamento centralizado do acesso, recomendamos que você use Centro de Identidade do AWS IAM (IAM Identity Center) para gerenciar o acesso às suas contas e permissões dentro dessas contas. Para obter mais alternativas, consulte as informações a seguir.
+ Para saber mais sobre as práticas recomendadas, consulte [Práticas recomendadas de segurança no IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/best-practices.html) no *Guia do usuário do IAM*.
+ Para criar AWS credenciais de curto prazo, consulte [Credenciais de segurança temporárias](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_temp.html) no Guia do *usuário do IAM*.
+ Para saber mais sobre outros provedores de AWS SDK para C\$1\$1 credenciais, consulte Provedores de [credenciais padronizados no Guia de](https://docs.aws.amazon.com/sdkref/latest/guide/standardized-credentials.html) Referência de *Ferramentas AWS SDKs e Ferramentas*.
# Obtendo o AWS SDK para C\$1\$1 do código-fonte
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
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- # Repo directory name and packageName
aws-sdk-cpp\aws-cpp-sdk-s3 # Example: Package name is s3
```
## Pré-requisitos
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
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
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
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` ..
```
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` ..
```
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
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- # Repo directory name and packageName
aws-sdk-cpp\aws-cpp-sdk-s3 # Example: Package name is s3
```
## Pré-requisitos
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
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
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
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
[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
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
#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. 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
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
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).
# Obtendo o AWS SDK para C\$1\$1 de um gerenciador de pacotes
**Importante**
Se você estiver usando um gerenciador de pacotes, como homebrew ou vcpkg:
Depois de atualizar o SDK para C\$1\$1 para uma nova versão, você precisa recompilar todas as bibliotecas ou executáveis que dependam do SDK.
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- # Repo directory name and packageName
aws-sdk-cpp\aws-cpp-sdk-s3 # Example: Package name is s3
```
## Pré-requisitos
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.
------
#### [ Linux/macOS ]
Para usar o AWS SDK para C\$1\$1 no Linux/macOS, você precisa de um dos seguintes:
+ GNU Compiler Collection (GCC) 4.9 ou posterior, ou
+ Clang 3.3 ou posterior.
------
#### [ Windows ]
Para usar o AWS SDK para C\$1\$1 no Windows, 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.
------
## Acessar o SDK usando o vcpkg
**Importante**
A distribuição vcpkg disponível é suportada por colaboradores externos e não é fornecida por meio do. AWS A versão mais recente está sempre disponível por meio da [instalação do código-fonte](sdk-from-source.md).
O [vcpkg](https://github.com/Microsoft/vcpkg) é um gerenciador de pacotes atualizado e mantido por colaboradores externos. Observe que esse gerenciador de pacotes não é fornecido AWS e pode não refletir a versão mais recente disponível para AWS SDK para C\$1\$1 o. Há um atraso entre o lançamento de uma versão AWS e a disponibilização por meio de um gerenciador de pacotes externo. A versão mais recente está sempre disponível por meio da [instalação do código-fonte](sdk-from-source.md).
Você deve instalar o [vcpkg](https://github.com/Microsoft/vcpkg) em seu sistema.
+ Faça o download e inicialize o [vcpkg](https://github.com/Microsoft/vcpkg) seguindo as instruções no GitHub Readme do vcpkg, substituindo as seguintes opções quando solicitado:
+
Como parte dessas instruções, você é orientado a inserir:
```
.\vcpkg\vcpkg install [packages to install]
```
Para instalar o SDK inteiro, insira `.\vcpkg\vcpkg install "aws-sdk-cpp[*]" --recurse` ou indique somente serviços específicos do SDK a serem instalados anexando um nome de pacote entre colchetes, por exemplo, `.\vcpkg\vcpkg install "aws-sdk-cpp[s3, ec2]" --recurse`.
A saída exibe mensagens, incluindo as seguintes:
```
CMake projects should use: "-DCMAKE_TOOLCHAIN_FILE=C:/dev/vcpkg/vcpkg/scripts/buildsystems/vcpkg.cmake"
```
+ Copie o `-DCMAKE_TOOLCHAIN_FILE` comando completo para usar CMake mais tarde. O GitHub Readme vcpkg também instrui sobre onde usá-lo para seu conjunto de ferramentas.
+ Talvez você também precise observar o tipo de configuração de compilação que você instalou por meio do vcpkg. A saída do console mostra a configuração de compilação e a versão do SDK. O exemplo de saída a seguir indica que a configuração de compilação é “x86-windows” e a AWS SDK para C\$1\$1 versão instalada é 1.8.
```
The following packages will be built and installed:
aws-sdk-cpp[core,dynamodb,kinesis,s3]:x86-windows -> 1.8.126#6
```
Depois de instalar o AWS SDK para C\$1\$1, você pode desenvolver seu próprio aplicativo usando o SDK. O exemplo mostrado em [Criar uma aplicação simples](build-cmake.md) relata os buckets do Amazon S3 de sua propriedade.
# Solução de problemas de compilação do AWS SDK for C\$1\$1
Ao criar a AWS SDK para C\$1\$1 partir do código-fonte, alguns dos seguintes problemas comuns de compilação podem surgir.
**Topics**
+ [CMake Erro: Não foi possível encontrar um arquivo de configuração de pacote fornecido por "AWSSDK”](#could-not-find-package)
+ [CMake Erro: não foi possível encontrar o arquivo de carregamento (e você está no SDK versão 1.8)](#could-not-load-file)
+ [CMake Erro: Não foi possível encontrar o arquivo de carregamento](#could-not-load-file2)
+ [Erro de rutime: não é possível continuar porque a `aws-*.dll` não foi encontrada.](#dll-was-not-found)
## CMake Erro: Não foi possível encontrar um arquivo de configuração de pacote fornecido por "AWSSDK”
CMake gera o seguinte erro se não conseguir encontrar o SDK instalado.
```
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.
```
Para resolver esse erro, diga CMake onde encontrar o SDK instalado (por exemplo, a pasta que foi gerada como resultado da instalação do SDK ([Windows](setup-windows.md), [Linux/macOS](setup-linux.md)). Insira o comando a seguir antes da primeira chamada para `find_package()` no arquivo `CMakeLists.txt`. Consulte [Criação de um aplicativo simples usando o AWS SDK for C\$1\$1](build-cmake.md) para ver um exemplo.
```
list(APPEND CMAKE_PREFIX_PATH "C:\\Program Files (x86)\\aws-cpp-sdk-all\\lib\\cmake")
```
## CMake Erro: não foi possível encontrar o arquivo de carregamento (e você está no SDK versão 1.8)
CMake gera o seguinte erro se não conseguir encontrar as bibliotecas instaladas.
```
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
```
Para resolver esse erro, diga CMake onde encontrar o SDK instalado (por exemplo, a pasta que foi gerada como resultado da instalação do SDK ([Windows](setup-windows.md), [Linux/macOS](setup-linux.md)). Insira os comandos a seguir antes da primeira chamada para `find_package()` no arquivo `CMakeLists.txt`. Consulte [Criação de um aplicativo simples usando o AWS SDK for C\$1\$1](build-cmake.md) para ver um exemplo.
```
#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()
```
Essa solução é somente para a v1.8 do SDK porque essas dependências são tratadas de forma diferente nas versões posteriores. A versão 1.9 resolve esses problemas introduzindo uma camada intermediária entre as bibliotecas `aws-sdk-cpp` e `aws-c-*`. Essa nova camada é chamada `aws-crt-cpp` e é um submódulo git do SDK para C\$1\$1. `aws-crt-cpp` também tem as bibliotecas `aws-c-*` (incluindo `aws-c-common`, `aws-checksums`, ` aws-c-event-stream` etc.) como seus próprios submódulos git. Isso permite que o SDK para C\$1\$1 acesse todas as bibliotecas CRT recursivamente e melhore o processo de compilação.
## CMake Erro: Não foi possível encontrar o arquivo de carregamento
CMake gera o seguinte erro se não conseguir encontrar as bibliotecas instaladas.
```
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
```
Para resolver esse erro, peça CMake para criar bibliotecas compartilhadas. Insira o comando a seguir antes da primeira chamada para `find_package()` no arquivo `CMakeLists.txt`. Consulte [Criação de um aplicativo simples usando o AWS SDK for C\$1\$1](build-cmake.md) para ver um exemplo.
```
set(BUILD_SHARED_LIBS ON CACHE STRING "Link to shared libraries by default.")
```
## Erro de rutime: não é possível continuar porque a `aws-*.dll` não foi encontrada.
CMake gera um erro semelhante ao seguinte se não conseguir encontrar uma DLL necessária.
```
The code execution cannot proceed because aws-cpp-sdk-[dynamodb].dll was not found. Reinstalling the program may fix this problem.
```
Esse erro ocorre porque as bibliotecas ou os executáveis necessários para o SDK para C\$1\$1 não estão disponíveis na mesma pasta que os executáveis da sua aplicação. Para resolver esse erro, copie a saída da compilação do SDK em seu local de executável. O nome do arquivo DLL específico do erro variará dependendo dos AWS serviços que você está usando. Execute *um* destes procedimentos:
+ Copie o conteúdo da `/bin` pasta da AWS SDK para C\$1\$1 instalação para a pasta de compilação do seu aplicativo.
+ Em seu `CMakeLists.txt` arquivo, use a macro AWSSDK\$1CPY \$1DYN\$1LIBS para copiá-los para você.
Adicione uma chamada a um `AWSSDK_CPY_DYN_LIBS(SERVICE_LIST "" ${CMAKE_CURRENT_BINARY_DIR})` ou `AWSSDK_CPY_DYN_LIBS(SERVICE_LIST "" ${CMAKE_CURRENT_BINARY_DIR}/${CMAKE_BUILD_TYPE})` ao arquivo `CMakeLists.txt` para usar essa macro a fim de fazer a cópia para você. Consulte [Criação de um aplicativo simples usando o AWS SDK for C\$1\$1](build-cmake.md) para ver um exemplo.
Escolha o caminho de cópia correto para seu ambiente de compilação. A compilação via linha de comando geralmente coloca a saída da compilação em uma subpasta (`/Debug`), mas o Visual Studio e outros IDEs geralmente não. Verifique onde estão os executáveis de saída e garanta que a macro esteja fazendo a cópia nesse local. Ao fazer esses tipos de alteração, é prática recomendável excluir o conteúdo do diretório de saída para que você tenha um ponto de partida limpo para a próxima compilação.