Pré-requisitos Etapa 1: Instalar g++ e pacotes de desenvolvimento necessários Etapa 2: instalar o CMake Etapa 3: Obter e criar o SDK para C++Etapa 4: criar C++ e arquivos CMakeLists Etapa 5: Compilar e executar o código C++Etapa 6: limpar

Tutorial de C++ para AWS Cloud9

Este tutorial permite que você execute código C++ em um ambiente de AWS Cloud9 desenvolvimento. O código também usa recursos fornecidos pelo AWS SDK for C++, uma biblioteca modular, multiplataforma e de código aberto que você pode usar para se conectar à Amazon Web Services.

Seguir este tutorial e criar essa amostra pode resultar em cobranças em sua AWS conta. Isso inclui possíveis cobranças por serviços como Amazon EC2 e Amazon S3. Para obter mais informações, consulte Amazon EC2 Pricing e Amazon S3 Pricing.

Tópicos

Pré-requisitos
Etapa 1: Instalar g++ e pacotes de desenvolvimento necessários
Etapa 2: instalar o CMake
Etapa 3: Obter e criar o SDK para C++
Etapa 4: criar C++ e arquivos CMakeLists
Etapa 5: Compilar e executar o código C++
Etapa 6: limpar

Pré-requisitos

Antes de usar esse exemplo, verifique se suas configurações cumprem os requisitos a seguir.

Você deve ter um ambiente de AWS Cloud9 EC2 desenvolvimento existente. Este exemplo pressupõe que você já tenha um EC2 ambiente conectado a uma EC2 instância da Amazon que executa Amazon Linux ou Ubuntu Server. Caso tenha um tipo diferente de ambiente ou sistema operacional, poderá ser necessário adaptar as instruções desse exemplo para configurar ferramentas relacionadas. Para ter mais informações, consulte Criando um ambiente em AWS Cloud9.
Você tem o AWS Cloud9 IDE para o ambiente existente já aberto. Quando você abre um ambiente, AWS Cloud9 abre o IDE para esse ambiente em seu navegador da web. Para ter mais informações, consulte Abrir um ambiente no AWS Cloud9.

Etapa 1: Instalar g++ e pacotes de desenvolvimento necessários

Para criar e executar um aplicativo C++, você precisa de um utilitário comog++, que é um compilador C++ fornecido pela GNUComplier Collection (). GCC

Você também precisa adicionar arquivos de cabeçalho (pacotes -dev) para libcurl, libopenssl, libuuid, zlib e, opcionalmente, libpulse para suporte do Amazon Polly.

O processo de instalação de ferramentas de desenvolvimento varia ligeiramente se você estiver usando uma instância do Amazon Linux/Amazon Linux 2 ou uma instância do Ubuntu.

Etapa 2: instalar o CMake

Você precisa instalar a ferramenta cmake, que automatiza o processo de construção de arquivos executáveis a partir do código-fonte.

Na janela do IDE terminal, execute o seguinte comando para obter o arquivo necessário:
```
wget https://cmake.org/files/v3.18/cmake-3.18.0.tar.gz
```
Extraia os arquivos do arquivamento e navegue até o diretório que contém os arquivos descompactados:
```
tar xzf cmake-3.18.0.tar.gz
cd cmake-3.18.0
```
Em seguida, execute um script bootstrap e instale cmake, executando os seguintes comandos:
```
./bootstrap
make
sudo make install
```
Confirme se você instalou a ferramenta executando o seguinte comando:
```
cmake --version
```

Etapa 3: Obter e criar o SDK para C++

Para configurar o AWS SDK para C++, você pode criar você SDK mesmo diretamente da fonte ou baixar as bibliotecas usando um gerenciador de pacotes. Você pode encontrar detalhes sobre as opções disponíveis em Introdução ao uso do AWS SDK para C++ no Guia do AWS SDK for C++ desenvolvedor.

Este exemplo demonstra o uso git para clonar o SDK código-fonte e criar o cmake SDK para C++.

Clone o repositório remoto e obtenha todos os submódulos do Git recursivamente para o ambiente do AWS Cloud9 , executando o seguinte comando no terminal:
```
git clone --recurse-submodules https://github.com/aws/aws-sdk-cpp
```
Navegue até o novo aws-sdk-cpp diretório, crie um subdiretório para compilar o AWS SDK para C++ e, em seguida, navegue até ele:
```
cd aws-sdk-cpp
mkdir sdk_build
cd sdk_build
```
nota
Para economizar tempo, essa etapa cria apenas a parte do Amazon S3 do AWS SDK for C++. Se você quiser criar o completoSDK, omita o -DBUILD_ONLY=s3 do cmake comando.
A criação completa SDK para C++ pode levar mais de uma hora para ser concluída, dependendo dos recursos de computação disponíveis para sua EC2 instância Amazon ou seu próprio servidor.

Use cmake para criar a parte Amazon S3 do SDK para C++ no sdk_build diretório executando o seguinte comando:
```
cmake .. -DBUILD_ONLY=s3
```
Agora, execute o make install comando para que a compilação SDK possa ser acessada:
```
sudo make install
cd ..
```

Etapa 4: criar C++ e arquivos CMakeLists

Nesta etapa, você criará um arquivo C++ que permite que os usuários do projeto interajam com buckets do Amazon S3.

Você também cria um arquivo CMakeLists.txt que fornece instruções que são usadas pelo cmake para criar sua biblioteca C++.

No AWS Cloud9 IDE, crie um arquivo com esse conteúdo e salve o arquivo com o nome s3-demo.cpp na raiz (/) do seu ambiente.


#include <iostream>
#include <aws/core/Aws.h>
#include <aws/s3/S3Client.h>
#include <aws/s3/model/Bucket.h>
#include <aws/s3/model/CreateBucketConfiguration.h>
#include <aws/s3/model/CreateBucketRequest.h>
#include <aws/s3/model/DeleteBucketRequest.h>

// Look for a bucket among all currently available Amazon S3 buckets.
bool FindTheBucket(const Aws::S3::S3Client &s3Client,
                   const Aws::String &bucketName) {

    Aws::S3::Model::ListBucketsOutcome outcome = s3Client.ListBuckets();

    if (outcome.IsSuccess()) {

        std::cout << "Looking for a bucket named '" << bucketName << "'..."
                  << std::endl << std::endl;

        Aws::Vector<Aws::S3::Model::Bucket> bucket_list =
                outcome.GetResult().GetBuckets();

        for (Aws::S3::Model::Bucket const &bucket: bucket_list) {
            if (bucket.GetName() == bucketName) {
                std::cout << "Found the bucket." << std::endl << std::endl;

                return true;
            }
        }

        std::cout << "Could not find the bucket." << std::endl << std::endl;
    } else {
        std::cerr << "listBuckets error: "
                  << outcome.GetError().GetMessage() << std::endl;
    }

    return outcome.IsSuccess();
}

// Create an Amazon S3 bucket.
bool CreateTheBucket(const Aws::S3::S3Client &s3Client,
                     const Aws::String &bucketName,
                     const Aws::String &region) {

    std::cout << "Creating a bucket named '"
              << bucketName << "'..." << std::endl << std::endl;

    Aws::S3::Model::CreateBucketRequest request;
    request.SetBucket(bucketName);

    if (region != "us-east-1") {
        Aws::S3::Model::CreateBucketConfiguration createBucketConfig;
        createBucketConfig.SetLocationConstraint(
                Aws::S3::Model::BucketLocationConstraintMapper::GetBucketLocationConstraintForName(
                        region));
        request.SetCreateBucketConfiguration(createBucketConfig);
    }

    Aws::S3::Model::CreateBucketOutcome outcome =
            s3Client.CreateBucket(request);

    if (outcome.IsSuccess()) {
        std::cout << "Bucket created." << std::endl << std::endl;
    } else {
        std::cerr << "createBucket error: "
                  << outcome.GetError().GetMessage() << std::endl;
    }

    return outcome.IsSuccess();
}

// Delete an existing Amazon S3 bucket.
bool DeleteTheBucket(const Aws::S3::S3Client &s3Client,
                     const Aws::String &bucketName) {

    std::cout << "Deleting the bucket named '"
              << bucketName << "'..." << std::endl << std::endl;

    Aws::S3::Model::DeleteBucketRequest request;
    request.SetBucket(bucketName);

    Aws::S3::Model::DeleteBucketOutcome outcome =
            s3Client.DeleteBucket(request);

    if (outcome.IsSuccess()) {
        std::cout << "Bucket deleted." << std::endl << std::endl;
    } else {
        std::cerr << "deleteBucket error: "
                  << outcome.GetError().GetMessage() << std::endl;
    }

    return outcome.IsSuccess();
}

#ifndef EXCLUDE_MAIN_FUNCTION
// Create an S3 bucket and then delete it.
// Before and after creating the bucket, and again after deleting the bucket,
// try to determine whether that bucket still exists. 
int main(int argc, char *argv[]) {

    if (argc < 3) {
        std::cout << "Usage: s3-demo <bucket name> <AWS Region>" << std::endl
                  << "Example: s3-demo my-bucket us-east-1" << std::endl;
        return 1;
    }

    Aws::SDKOptions options;
    Aws::InitAPI(options);
    {
        Aws::String bucketName = argv[1];
        Aws::String region = argv[2];

        Aws::Client::ClientConfiguration config;

        config.region = region;

        Aws::S3::S3Client s3Client(config);

        if (!FindTheBucket(s3Client, bucketName)) {
            return 1;
        }

        if (!CreateTheBucket(s3Client, bucketName, region)) {
            return 1;
        }

        if (!FindTheBucket(s3Client, bucketName)) {
            return 1;
        }

        if (!DeleteTheBucket(s3Client, bucketName)) {
            return 1;
        }

        if (!FindTheBucket(s3Client, bucketName)) {
            return 1;
        }
    }
    Aws::ShutdownAPI(options);

    return 0;
}
#endif  // EXCLUDE_MAIN_FUNCTION

Crie um segundo arquivo com esse conteúdo e salve-o com o nome CMakeLists.txt na raiz (/) do seu ambiente. Esse arquivo permite compilar o código em um arquivo executável.


# A minimal CMakeLists.txt file for the AWS SDK for C++.

# The minimum version of CMake that will work.
cmake_minimum_required(VERSION 2.8)

# The project name.
project(s3-demo)

# Locate the AWS SDK for C++ package.
set(AWSSDK_ROOT_DIR, "/usr/local/")
set(BUILD_SHARED_LIBS ON)
find_package(AWSSDK REQUIRED COMPONENTS s3)

# The executable name and its source files.
add_executable(s3-demo s3-demo.cpp)

# The libraries used by your executable.
target_link_libraries(s3-demo ${AWSSDK_LINK_LIBRARIES})

Etapa 5: Compilar e executar o código C++

No diretório raiz do ambiente no qual você salvou a s3-demo.cpp e o CMakeLists.txt, execute cmake para compilar o projeto:
```
cmake . 
make
```

Agora você pode executar o programa da linha de comando. No comando a seguir, substitua my-unique-bucket-name por um nome exclusivo para o bucket do Amazon S3 e, se necessário, substitua us-east-1 pelo identificador de outra região da AWS onde você deseja criar um bucket.


./s3-demo my-unique-bucket-name us-east-1

Se o programa for executado com êxito, você verá um resultado semelhante a este:


Looking for a bucket named 'my-unique-bucket-name'...

Could not find the bucket.

Creating a bucket named 'my-unique-bucket-name'...

Bucket created.

Looking for a bucket named 'my-unique-bucket-name'...

Found the bucket.

Deleting the bucket named 'my-unique-bucket-name'...

Bucket deleted.

Looking for a bucket named 'my-unique-bucket-name'...

Could not find the bucket.

Etapa 6: limpar

Para evitar cobranças contínuas em sua AWS conta depois que você terminar de usar essa amostra, exclua o ambiente. Para obter instruções, consulte Excluir um ambiente no AWS Cloud9.

Atenção O Javascript está desativado ou não está disponível no seu navegador.

Para usar a documentação da AWS, o Javascript deve estar ativado. Consulte as páginas de Ajuda do navegador para obter instruções.

Convenções do documento

Tutorial de Java

Tutorial do Python