Prérequis Étape 1 : Installer g++ et les paquets de développement requis Étape 2 : Installation de CMake Étape 3 : Obtenir et générer le kit SDK for C++Étape 4 : Création de MakeLists fichiers C++ et C Étape 5 : Créer et exécuter le code C++Étape 6 : Nnettoyer

Tutoriel C++ pour AWS Cloud9

Ce didacticiel vous permet d'exécuter du code C++ dans un environnement de AWS Cloud9 développement. Le code utilise également les ressources fournies par AWS SDK for C++, une bibliothèque open source modularisée, multiplateforme, que vous pouvez utiliser pour vous connecter à Amazon Web Services.

La suite de ce didacticiel et la création de cet exemple peuvent entraîner des frais sur votre AWS compte. Il peut s'agir de frais pour des services tels qu'Amazon EC2 et Amazon S3. Pour en savoir plus, consultez les sections Tarification Amazon EC2 et Tarification Amazon S3.

Rubriques

Prérequis
Étape 1 : Installer g++ et les paquets de développement requis
Étape 2 : Installation de CMake
Étape 3 : Obtenir et générer le kit SDK for C++
Étape 4 : Création de MakeLists fichiers C++ et C
Étape 5 : Créer et exécuter le code C++
Étape 6 : Nnettoyer

Prérequis

Avant d'utiliser cet exemple, vérifiez que votre configuration respecte les conditions requises suivantes :

Vous devez disposer d'un environnement de développement AWS Cloud9 EC2 existant. Cet exemple suppose que vous disposez déjà d'un environnement EC2 connecté à une instance Amazon EC2 s'exécutant sur Amazon Linux ou Ubuntu Server. Si vous utilisez un autre type d'environnement ou de système d'exploitation, vous devrez peut-être adapter les instructions de cet exemple pour configurer les outils associés. Pour plus d'informations, veuillez consulter Création d'un environnement dans AWS Cloud9.
L'IDE AWS Cloud9 correspondant à l'environnement existant est déjà ouvert. Lorsque vous ouvrez un environnement, AWS Cloud9 ouvre l'IDE associé à cet environnement dans votre navigateur web. Pour plus d'informations, veuillez consulter Ouverture d'un environnement dans AWS Cloud9.

Étape 1 : Installer g++ et les paquets de développement requis

Pour créer et exécuter une application C ++, vous avez besoin d'un utilitaire tel que g++, qui est un compilateur C ++ fourni par la GNU Compiler Collection (GCC).

Vous devez également ajouter des fichiers d'en-tête (paquets -dev) pour libcurl, libopenssl, libuuid, zlib et éventuellement libpulse pour la prise en charge d'Amazon Polly.

Le processus d'installation des outils de développement varie légèrement selon que vous utilisez une instance Amazon Linux/Amazon Linux 2 ou une instance Ubuntu.

Étape 2 : Installation de CMake

Vous devez installer l'outil cmake, qui automatise le processus de création de fichiers exécutables à partir du code source.

Dans la fenêtre de terminal de l'IDE, exécutez la commande suivante pour obtenir l'archive requise :
```
wget https://cmake.org/files/v3.18/cmake-3.18.0.tar.gz
```
Extrayez les fichiers de l'archive et accédez au répertoire contenant les fichiers décompressés :
```
tar xzf cmake-3.18.0.tar.gz
cd cmake-3.18.0
```
Ensuite, exécutez un script d'amorçage et installez cmake en exécutant les commandes suivantes :
```
./bootstrap
make
sudo make install
```
Vérifiez que vous avez installé l'outil en exécutant la commande suivante :
```
cmake --version
```

Étape 3 : Obtenir et générer le kit SDK for C++

Pour configurer le kit SDK AWS for C++, vous pouvez soit compiler le SDK vous-même directement à partir de la source, soit télécharger les bibliothèques à l'aide d'un gestionnaire de paquets. Pour plus de détails sur les options disponibles, consultez Démarrer avec le kit SDK AWS pour C++dans l eGuide du développeurAWS SDK for C++.

Cet exemple illustre l'utilisation de git pour cloner le code source du kit SDK et de cmake pour générer le kit SDK for C++.

Clonez le référentiel distant et obtenez tous les sous-modules git récursivement pour votre environnement AWS Cloud9 en exécutant la commande suivante dans le terminal :
```
git clone --recurse-submodules https://github.com/aws/aws-sdk-cpp
```
Accédez au nouveau répertoire aws-sdk-cpp, créez un sous-répertoire pour compiler le kit SDK AWS pour C++, puis accédez à ce répertoire :
```
cd aws-sdk-cpp
mkdir sdk_build
cd sdk_build
```
Note
Pour gagner du temps, cette étape génère uniquement la partie Amazon S3 du AWS SDK for C++. Si vous souhaitez créer le kit SDK complet, omettez le -DBUILD_ONLY=s3 dans la commande cmake.
La compilation du kit SDK complet pour C++ peut prendre une heure, en fonction des ressources de calcul disponibles pour votre instance Amazon EC2 ou votre propre serveur.

Utilisez cmake pour générer la partie Amazon S3 du kit SDK pour C++ dans le répertoire sdk_build en exécutant la commande suivante :
```
cmake .. -DBUILD_ONLY=s3
```
Maintenant, exécutez la commande make install afin que le kit SDK compilé soit accessible :
```
sudo make install
cd ..
```

Étape 4 : Création de MakeLists fichiers C++ et C

Au cours de cette étape, vous créez un fichier C++ qui permet aux utilisateurs du projet d'interagir avec les compartiments Amazon S3.

Vous créez également un fichier CMakeLists.txt qui fournit des instructions utilisées par cmake pour créer votre bibliothèque C ++.

Dans l'IDE AWS Cloud9, créez un fichier avec ce contenu et enregistrez-le sous le nom s3-demo.cpp à la racine (/) de votre environnement.


#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 TESTING_BUILD
// 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 bucket_name = argv[1];
        Aws::String region = argv[2];

        Aws::Client::ClientConfiguration config;

        config.region = region;

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

        if (!FindTheBucket(s3_client, bucket_name)) {
            return 1;
        }

        if (!CreateTheBucket(s3_client, bucket_name, region)) {
            return 1;
        }

        if (!FindTheBucket(s3_client, bucket_name)) {
            return 1;
        }

        if (!DeleteTheBucket(s3_client, bucket_name)) {
            return 1;
        }

        if (!FindTheBucket(s3_client, bucket_name)) {
            return 1;
        }
    }
    Aws::ShutdownAPI(options);

    return 0;
}
#endif  // TESTING_BUILD

Créez un second fichier avec ce contenu et enregistrez-le sous le nom CMakeLists.txt à la racine (/) de votre environnement. Ce fichier vous permet de créer votre code dans un fichier exécutable.


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

Étape 5 : Créer et exécuter le code C++

Dans le répertoire racine de votre environnement dans lequel vous avez enregistré s3-demo.cpp et CMakeLists.txt, exécutez cmake pour créer votre projet :
```
cmake . 
make
```

À présent, vous pouvez exécuter votre programme à partir de la ligne de commande. Dans la commande suivante, remplacez my-unique-bucket-name par un nom unique pour le compartiment Amazon S3 et, si nécessaire, remplacez us-east-1 par l'identifiant d'une autre région AWS dans laquelle vous souhaitez créer un compartiment.


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

Si le programme s'exécute correctement, vous obtenez une sortie similaire à ce qui suit :


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.

Étape 6 : Nnettoyer

Afin d'éviter des frais permanents sur votre compte AWS une fois que vous avez fini d'utiliser cet exemple, supprimez l'environnement. Pour obtenir des instructions, consultez Suppression d'un environnement dans AWS Cloud9.

Avertissement JavaScript est désactivé ou n'est pas disponible dans votre navigateur.

Pour que vous puissiez utiliser la documentation AWS, Javascript doit être activé. Vous trouverez des instructions sur les pages d'aide de votre navigateur.

Conventions de rédaction

Tutoriel Java

Tutoriel Python