Requisitos previos Paso 1: Instalar g++ y los paquetes de desarrollo necesarios Paso 2: Instalar CMake Paso 3: Obtener y compilar el SDK para C++Paso 4: Crear archivos de C++ y CMakeLists 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 de C++ en un entorno de desarrollo de AWS Cloud9. 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.

El uso de este tutorial y la creación de esta muestra pueden generar cargos en su cuenta de AWS. Entre estos se incluyen posibles cargos por servicios como Amazon EC2 y Amazon S3. Para obtener más información, consulte Precios de Amazon EC2 y Precios de Amazon S3.

Temas

Requisitos previos
Paso 1: Instalar g++ y los paquetes de desarrollo necesarios
Paso 2: Instalar CMake
Paso 3: Obtener y compilar el SDK para C++
Paso 4: Crear archivos de C++ y CMakeLists
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 desarrollo de AWS Cloud9 EC2. En este ejemplo, se da por hecho que ya tiene un entorno de EC2 que está conectado a una instancia de Amazon EC2 que ejecuta Amazon Linux o Ubuntu Server. 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 Creación de un entorno en AWS Cloud9.
Ya tiene abierto el IDE de AWS Cloud9 para el entorno existente. Al abrir un entorno, AWS Cloud9 abre el IDE de 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 compilar y ejecutar una aplicación de C++, necesita una utilidad como g++, que sea un compilador de C++ proporcionado por GNU Complier 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 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 terminal del IDE, ejecute el siguiente comando para obtener el archivo requerido:
```
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: Obtener y compilar el SDK para C++

Para configurar AWSSDK para C++, puede crear el SDK usted mismo directamente desde la fuente o descargar las bibliotecas utilizando un administrador de paquetes. Puede encontrar detalles sobre las opciones disponibles en Introducción al uso de AWS SDK para C++ en la Guía para desarrolladores de AWS SDK for C++.

En esta muestra se explica cómo usar git para clonar el código fuente del SDK y cmake para crear el 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
```
Desplácese hasta el nuevo directorio aws-sdk-cpp, cree un subdirectorio en el que crear el AWS SDK para C++ y, a continuación, diríjase a:
```
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 desea crear el SDK completo, omita el fragmento -DBUILD_ONLY=s3 del comando cmake.
La creación del SDK para C++ completo puede tardar más de una hora en completarse en función de los recursos informáticos disponibles para su instancia de Amazon EC2 o para su propio servidor.

Use cmake para compilar la sección Amazon S3 del SDK para C++ en el directorio sdk_build mediante la ejecución del siguiente comando:
```
cmake .. -DBUILD_ONLY=s3
```
A continuación, ejecute el comando make install para que se pueda acceder al SDK creado:
```
sudo make install
cd ..
```

Paso 4: Crear archivos de C++ y CMakeLists

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 el IDE de AWS Cloud9, 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 apliquen cargos continuos en su cuenta de AWS después de usar esta muestra, elimine 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