Requisitos previos Paso 1: Instalar g++ y los paquetes de desarrollo necesarios Paso 2: instalar el CMake Paso 3: Obtenga y compile el SDK para C++Paso 4: Crea C++ y CMakeLists archivos Paso 5: Compilar y ejecutar el código de C++Paso 6: limpiar

Tutorial de C++ para AWS Cloud9

Este tutorial le permite ejecutar código C++ en un entorno de AWS Cloud9 desarrollo. El código también utiliza los recursos proporcionados por el AWS SDK for C++, una biblioteca modular, multiplataforma y de código abierto que puede utilizar para conectarse a Amazon Web Services.

Si sigue este tutorial y crea este ejemplo, es posible que se le cobren cargos a su AWS cuenta. Estos incluyen posibles cargos por servicios como Amazon EC2 y Amazon S3. Para obtener más información, consulte Amazon EC2 Pricing y Amazon S3 Pricing.

Temas

Requisitos previos
Paso 1: Instalar g++ y los paquetes de desarrollo necesarios
Paso 2: instalar el CMake
Paso 3: Obtenga y compile el SDK para C++
Paso 4: Crea C++ y CMakeLists archivos
Paso 5: Compilar y ejecutar el código de C++
Paso 6: limpiar

Requisitos previos

Antes de utilizar este ejemplo, asegúrese de que su configuración cumpla los siguientes requisitos:

Debe tener un entorno de AWS Cloud9 EC2 desarrollo existente. En este ejemplo se supone que ya tienes un EC2 entorno conectado a una EC2 instancia de Amazon que ejecuta Amazon Linux o Ubuntu Servidor. Si tiene otro tipo de entorno o sistema operativo, es posible que tenga que adaptar las instrucciones de este ejemplo para configurar herramientas relacionadas. Para obtener más información, consulte Crear un entorno en AWS Cloud9.
Ya tiene abierto el entorno existente. AWS Cloud9 IDE Al abrir un entorno, AWS Cloud9 abre el IDE correspondiente a ese entorno en el navegador web. Para obtener más información, consulte Apertura de un entorno en AWS Cloud9.

Paso 1: Instalar g++ y los paquetes de desarrollo necesarios

Para crear y ejecutar una aplicación de C++, se necesita una utilidad comog++, por ejemplo, un compilador de C++ proporcionado por GNUComplier Collection () GCC.

También tiene que agregar archivos de encabezado (paquetes -dev) para libcurl, libopenssl, libuuid, zlib y, de manera opcional, libpulse para obtener asistencia de Amazon Polly.

El proceso de instalación de herramientas de desarrollo varía ligeramente según si utiliza una instancia de Amazon Linux/Amazon Linux 2 o una instancia de Ubuntu.

Paso 2: instalar el CMake

Debe instalar la herramienta cmake, que automatiza el proceso de compilación de archivos ejecutables a partir del código fuente.

En la ventana del IDE terminal, ejecuta el siguiente comando para obtener el archivo necesario:
```
wget https://cmake.org/files/v3.18/cmake-3.18.0.tar.gz
```
Extraiga los archivos del archivo y vaya al directorio que contiene los archivos desempaquetados:
```
tar xzf cmake-3.18.0.tar.gz
cd cmake-3.18.0
```
A continuación, ejecute un script de arranque y ejecute los comandos siguientes para instalar cmake:
```
./bootstrap
make
sudo make install
```
Para confirmar que ha instalado la herramienta, ejecute el comando siguiente:
```
cmake --version
```

Paso 3: Obtenga y compile el SDK para C++

Para configurarlo AWS SDK para C++, puede compilarlo SDK usted mismo directamente desde la fuente o descargar las bibliotecas mediante un administrador de paquetes. Encontrarás información detallada sobre las opciones disponibles en Cómo empezar a usar el software AWS SDK para C++ en la Guía para AWS SDK for C++ desarrolladores.

En este ejemplo se muestra git cómo clonar el código SDK fuente y compilarlo cmake SDK para C++.

Clone el repositorio remoto y obtenga todos los submódulos de Git repetidamente para su entorno de AWS Cloud9 ejecutando el siguiente comando en el terminal:
```
git clone --recurse-submodules https://github.com/aws/aws-sdk-cpp
```
Navegue hasta el nuevo aws-sdk-cpp directorio, cree un subdirectorio en el que compilar el directorio AWS SDK para C++ y, a continuación, navegue hasta ese directorio:
```
cd aws-sdk-cpp
mkdir sdk_build
cd sdk_build
```
nota
Para ahorrar tiempo, en este paso se crea solo la sección Amazon S3 del AWS SDK for C++. Si quieres compilarlo completoSDK, omítelo en el -DBUILD_ONLY=s3 cmake comando.
La creación de la SDK versión completa para C++ puede tardar más de una hora en completarse, en función de los recursos informáticos disponibles para su EC2 instancia de Amazon o su propio servidor.

cmakeUtilícelo para compilar la parte de Amazon S3 SDK para C++ en el sdk_build directorio ejecutando el siguiente comando:
```
cmake .. -DBUILD_ONLY=s3
```
Ahora ejecute el make install comando para poder SDK acceder a la compilación:
```
sudo make install
cd ..
```

Paso 4: Crea C++ y CMakeLists archivos

En este paso va a crear un archivo de C++ que permita a los usuarios del proyecto interactuar con los buckets de Amazon S3.

También puede crear un archivo CMakeLists.txt con instrucciones que cmake utiliza para crear su biblioteca de C++.

En AWS Cloud9 IDE, cree un archivo con este contenido y guárdelo con el nombre s3-demo.cpp en la raíz (/) de su entorno.


#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

Cree un archivo con este contenido y guárdelo con el nombre CMakeLists.txt en la raíz (/) de su entorno. Este archivo le permite compilar el código en un archivo ejecutable.


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

Paso 5: Compilar y ejecutar el código de C++

En el directorio raíz de su entorno en el que ha guardado los archivos s3-demo.cpp y CMakeLists.txt, ejecute cmake para crear su proyecto:
```
cmake . 
make
```

Ahora puede ejecutar el programa desde la línea de comandos. En el siguiente comando, reemplace my-unique-bucket-name por un nombre único para el bucket de Amazon S3 y, si es necesario, reemplace us-east-1 por el identificador de otra región de AWS en la que desee crear un bucket.


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

Si el programa se ejecuta correctamente, se devolverá un resultado similar al siguiente:


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.

Paso 6: limpiar

Para evitar que se sigan realizando cargos en tu AWS cuenta una vez que hayas terminado con este ejemplo, elimina el entorno. Para obtener instrucciones, consulte Eliminación de un entorno en AWS Cloud9.

Aviso JavaScript está desactivado o no está disponible en su navegador.

Para utilizar la documentación de AWS, debe estar habilitado JavaScript. Para obtener más información, consulte las páginas de ayuda de su navegador.

Convenciones del documento

Tutorial de Java

Tutorial de Python