aws-sdk-cpp相关（aws dynamodb/s3/sqs c++用法）

最新推荐文章于 2024-01-09 08:52:44 发布
最新推荐文章于 2024-01-09 08:52:44 发布
阅读量1.3k 收藏 1
点赞数
分类专栏： 数据库
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/a_l_a_n/article/details/104845103
版权

１、安装aws-sdk-cpp

git clone https://github.com/aws/aws-sdk-cpp.git
cd aws-sdk-cpp/
mkdir build
cd build/
cmake .. # cmake -DBUILD_ONLY="s3;dynamodb" ..只编译s3,dynampdb
make # make -j8
sudo make install # 头文件位于/usr/local/include，动态库文件位于/usr/local/lib

2、dynamodb使用

官方例子：https://docs.amazonaws.cn/sdk-for-cpp/v1/developer-guide/examples-dynamodb.html

dynamodb保留的关键字：https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/ReservedWords.html

dynamodb.cc: 

#include <iostream>
#include "aws/core/Aws.h"
#include "aws/core/auth/AWSCredentialsProvider.h"
#include "aws/core/utils/Outcome.h"
#include "aws/dynamodb/DynamoDBClient.h"
#include "aws/dynamodb/model/AttributeValue.h"
#include "aws/dynamodb/model/AttributeValueUpdate.h"
#include "aws/dynamodb/model/DescribeTableRequest.h"
#include "aws/dynamodb/model/PutItemRequest.h"
#include "aws/dynamodb/model/GetItemRequest.h"
#include "aws/dynamodb/model/UpdateItemRequest.h"
#include "aws/dynamodb/model/QueryRequest.h"
#include "aws/dynamodb/model/ScanRequest.h"
#include "aws/dynamodb/model/DeleteItemRequest.h"
#include "aws/dynamodb/model/BatchWriteItemRequest.h"
#include "aws/dynamodb/model/BatchGetItemRequest.h"

using AttributeValue = Aws::DynamoDB::Model::AttributeValue;
using AttributeValueUpdate = Aws::DynamoDB::Model::AttributeValueUpdate;

std::string table = "alan_test";

auto NumberToAttribute = [](auto num) {
    AttributeValue av;
    av.SetN(std::to_string(num).c_str());
    return av;
};

AttributeValue StringToAttribute(const std::string &str) {
  AttributeValue av;
  av.SetS(Aws::String(str.c_str(), str.size()));
  return av;
}

AttributeValueUpdate AttributeToUpdate(AttributeValue av) {
  AttributeValueUpdate avu;
  avu.SetValue(av);
  return avu;
};

void PrintItem(const Aws::Map<Aws::String, AttributeValue>& item) {
  // id
  int id_ = 0;
  if (item.count("id")) {
    id_ = atoi(item.find("id")->second.GetN().c_str());
    // id_ = atoi(item.at("id").GetN().c_str());
  }
  // class
  int class_ = 0;
  if (item.count("class")) {
    class_ = atoi(item.find("class")->second.GetN().c_str());
  }
  // name
  std::string name_ = "";
  if (item.count("name"))
    name_ = item.find("name")->second.GetS().c_str();

  std::cout << "id: " << id_ << ", class: " << class_ << ", name: " << name_ << std::endl;
}

int main(int argc, char* argv[])
{
  Aws::SDKOptions options;
  // options.loggingOptions.logLevel = Aws::Utils::Logging::LogLevel::Trace;
  Aws::InitAPI(options);

  Aws::Auth::AWSCredentials credentials("access key", "secret key");
  Aws::Client::ClientConfiguration client_config;
  client_config.region = "cn-northwest-1";
  // client_config.requestTimeoutMs = 300000;
  // client_config.endpointOverride = "localhost:8000";
  // client_config.endpointOverride = "10.202.91.2:88";  // dynamodb服务器地址和端口
  // client_config.scheme = Aws::Http::Scheme::HTTPS;
  Aws::DynamoDB::DynamoDBClient dynamodb_client(credentials, client_config);
  std::cout << "success initial !" << std::endl;
  getchar();
  //----------------------------------------------------------------------------
  {
    // check if the table exists
    Aws::DynamoDB::Model::DescribeTableRequest request;
    request.SetTableName(table.c_str());
    auto result = dynamodb_client.DescribeTable(request);
    if (!result.IsSuccess()) {
      std::cout << "Fail to open table " << table.c_str() << ": "
                << result.GetError().GetExceptionName().c_str() << "\n"
                << result.GetError().GetMessage().c_str();
    }
  }
  std::cout << "success check table !" << std::endl;
  getchar();
  //----------------------------------------------------------------------------
  {
    // put item
    Aws::DynamoDB::Model::PutItemRequest request;
    request.SetTableName(table.c_str());
    request.AddItem("id", NumberToAttribute(1));
    request.AddItem("class", NumberToAttribute(4));
    request.AddItem("name", StringToAttribute("alan"));
    // Aws::Map<Aws::String, Aws::DynamoDB::Model::AttributeValue> item;
    // // id.
    // item.insert(std::make_pair("id", AttributeValue("test.bag")));
    // // timestamp
    // AttributeValue timestamp_av;
    // timestamp_av.SetN("10010");
    // item.insert(std::make_pair("timestamp", timestamp_av));

    // // status
    // item.insert(std::make_pair("status", AttributeValue("unknow")));
    // request.SetItem(item);
    auto result = dynamodb_client.PutItem(request);
    if (!result.IsSuccess()) {
      std::cout << "Fail to put item: "
                << result.GetError().GetExceptionName().c_str() << "\n"
                << result.GetError().GetMessage().c_str() << std::endl;
    }
  }
  std::cout << "success put item !" << std::endl;
  getchar();
  //----------------------------------------------------------------------------
  {
    // get item（指定主键和排序键，item唯一）(get 1 item)
    // Aws::DynamoDB::Model::AttributeValue attribute_value;
    // attribute_value.SetS("test.bag");
    // get_request.SetKey({{"id", attribute_value}});
    Aws::DynamoDB::Model::GetItemRequest request;
    request.SetConsistentRead(true);
    request.SetTableName(table.c_str());
    request.SetExpressionAttributeNames({{"#name", "name"},
                                         {"#class", "class"}});

    Aws::StringStream stream;
    stream << "id" << ", " << "#name" << ", " << "#class";
    request.SetProjectionExpression(stream.str());

    request.AddKey("id", NumberToAttribute(1));
    request.AddKey("class", NumberToAttribute(4));

    auto result = dynamodb_client.GetItem(request); // Aws::DynamoDB::Model::GetItemOutcome result
    if (!result.IsSuccess() || result.GetResult().GetItem().size() == 0) {
      std::cout << "Fail to get item: "
                << result.GetError().GetExceptionName().c_str() << "\n"
                << result.GetError().GetMessage().c_str();
    }
    auto item = result.GetResult().GetItem();
    PrintItem(item);
  }
  std::cout << "success get item !" << std::endl;
  getchar();
  //----------------------------------------------------------------------------
  {
    // update item（不能更新主键和排序键）
    Aws::DynamoDB::Model::UpdateItemRequest request;
    request.SetTableName(table.c_str());

    request.AddKey("id", NumberToAttribute(1));
    request.AddKey("class", NumberToAttribute(4));
    // update_item_req.AddKey("id", AttributeValue("test.bag"));
    // update_item_req.AddKey("name", AttributeValue("alan"));
    request.AddAttributeUpdates("name", AttributeToUpdate(StringToAttribute("Alan")));

    // // id
    // AttributeValue id_av("good");
    // AttributeValueUpdate id_avu;
    // id_avu.SetValue(id_av);
    // update_item_req.AddAttributeUpdates("status", id_avu);
    // // time_start
    // AttributeValue time_start_av;
    // time_start_av.SetN("12345678.90");
    // AttributeValueUpdate time_start_avu;
    // time_start_avu.SetValue(time_start_av);
    // update_item_req.AddAttributeUpdates("time_start", time_start_avu);

    auto result = dynamodb_client.UpdateItem(request);
    if (!result.IsSuccess()) {
      std::cout << "Fail to update item: "
                << result.GetError().GetExceptionName().c_str() << "\n"
                << result.GetError().GetMessage().c_str();
    }
  }
  std::cout << "success update item !" << std::endl;
  getchar();
  //----------------------------------------------------------------------------
  {
    // query item (get 1+ item)
    Aws::DynamoDB::Model::QueryRequest request;
    request.SetConsistentRead(true);
    request.SetTableName(table.c_str());

    // query_req.AddExpressionAttributeNames("#status", "status");
    request.SetExpressionAttributeNames({{"#name", "name"},
                                         {"#class", "class"}});
    Aws::StringStream stream;
    stream << "id" << ", " << "#class" << ", " << "#name";
    request.SetProjectionExpression(stream.str());
    // query_req.SetProjectionExpression("id, #status, start_time");  // must assign key schema element

    request.SetKeyConditionExpression("id = :id"); // 必须指定主键相等条件
    request.SetFilterExpression("#name < :name");
    Aws::DynamoDB::Model::AttributeValue id_av, name_av;
    id_av.SetN("1");
    name_av.SetS("a");
    Aws::Map<Aws::String, AttributeValue> values = {{":id", id_av},
                                                    {":name", name_av}};
    // Aws::Map<Aws::String, AttributeValue> values;
    // values[Aws::String(":id")] = id_av;
    // values[Aws::String(":name")] = name_av;
    request.SetExpressionAttributeValues(values);

    request.SetScanIndexForward(false);  // 从大到小

    auto result = dynamodb_client.Query(request);
    if (!result.IsSuccess()) {
      std::cout << "Fail to query item: "
                << result.GetError().GetExceptionName().c_str() << "\n"
                << result.GetError().GetMessage().c_str();
    }
    auto items = result.GetResult().GetItems();
    for (const auto &item : items) {
      PrintItem(item);
    }
  }
  std::cout << "success query item !" << std::endl;
  getchar();
  //----------------------------------------------------------------------------
  {
    // scan table
    Aws::DynamoDB::Model::ScanRequest request;
    request.SetTableName(table.c_str());
    request.SetExpressionAttributeNames({{"#name", "name"},
                                         {"#class", "class"}});
    // scan_req.AddExpressionAttributeNames("#status", "status");
    // scan_req.AddExpressionAttributeNames("#timestamp", "timestamp");
    request.SetProjectionExpression("id, #name");
    request.SetFilterExpression("#class = :class"
                                " AND id = :id");
    Aws::DynamoDB::Model::AttributeValue id_av, class_av;
    id_av.SetN("2");
    class_av.SetN("4");
    Aws::Map<Aws::String, AttributeValue> values = {{":id", id_av},
                                                    {":class", class_av}};
    request.SetExpressionAttributeValues(values);

    Aws::Map<Aws::String, AttributeValue> last_key;
    // Aws::Vector<Aws::Map<Aws::String, AttributeValue>> all_items;
    do {
      if (last_key.size()) {
        request.SetExclusiveStartKey(last_key);
      }
      auto result = dynamodb_client.Scan(request);
      if (!result.IsSuccess()) {
        std::cout << "Scan error: " << result.GetError().GetMessage();
      }
        std::cout << "scan " << result.GetResult().GetScannedCount() << " items" << std::endl;
        std::cout << "match " << result.GetResult().GetCount() << " items" << std::endl;
      auto items = result.GetResult().GetItems();
      // all_items.insert(all_items.end(), items.begin(), items.end());
      for (const auto &item : items) {
        PrintItem(item);
      }
      last_key = result.GetResult().GetLastEvaluatedKey();
    } while (last_key.size());
  }
  std::cout << "success scan item !" << std::endl;
  getchar();
  //----------------------------------------------------------------------------
  {
    // delete item
    Aws::DynamoDB::Model::DeleteItemRequest request;
    request.SetTableName(table.c_str());

    request.AddKey("id", NumberToAttribute(1));
    request.AddKey("class", NumberToAttribute(1));
    // delete_item_req.SetKey({{"id", AttributeValue("test.bag")}});

    auto result = dynamodb_client.DeleteItem(request);
    if (!result.IsSuccess()) {
      std::cout << "Fail to delete item: "
                << result.GetError().GetExceptionName().c_str() << "\n"
                << result.GetError().GetMessage().c_str();
    }
  }
  std::cout << "success delete item !" << std::endl;
  getchar();
  //----------------------------------------------------------------------------
  {
    // batch write items
    Aws::Map<Aws::String, AttributeValue> item1;
    item1.insert(std::make_pair("id", NumberToAttribute(5)));
    item1.insert(std::make_pair("class", NumberToAttribute(5)));
    item1.insert(std::make_pair("name", StringToAttribute("5555")));
    Aws::DynamoDB::Model::PutRequest put_request1;
    put_request1.SetItem(item1);

    Aws::Map<Aws::String, AttributeValue> item2;
    item2.insert(std::make_pair("id", NumberToAttribute(6)));
    item2.insert(std::make_pair("class", NumberToAttribute(6)));
    item2.insert(std::make_pair("name", StringToAttribute("6666")));
    Aws::DynamoDB::Model::PutRequest put_request2;
    put_request2.SetItem(item2);

    Aws::Vector<Aws::DynamoDB::Model::WriteRequest> write_requests;
    write_requests.push_back(Aws::DynamoDB::Model::WriteRequest());
    write_requests.back().SetPutRequest(put_request1);
    write_requests.push_back(Aws::DynamoDB::Model::WriteRequest());
    write_requests.back().SetPutRequest(put_request2);

    // Aws::DynamoDB::Model::WriteRequest write_req;
    // write_req.SetPutRequest(put_req);
    // write_reqs.push_back(write_req);
    // Aws::DynamoDB::Model::WriteRequest write_req2;
    // write_req2.SetPutRequest(put_req2);
    // write_reqs.push_back(write_req2);

    Aws::DynamoDB::Model::BatchWriteItemRequest batch_request;
    batch_request.AddRequestItems(table.c_str(), write_requests);
    auto result = dynamodb_client.BatchWriteItem(batch_request);
    if (!result.IsSuccess()) {
      std::cout << "Fail to batch write item: "
                << result.GetError().GetExceptionName().c_str() << "\n"
                << result.GetError().GetMessage().c_str();
    }

    // Continue process throttled items.
    while (result.GetResult().GetUnprocessedItems().size() > 0) {
      batch_request.SetRequestItems(result.GetResult().GetUnprocessedItems());
      result = dynamodb_client.BatchWriteItem(batch_request);
      if (!result.IsSuccess()) {
        std::cout << "Fail to batch write item: "
                  << result.GetError().GetExceptionName().c_str() << "\n"
                  << result.GetError().GetMessage().c_str();
      }
    }
  }

/*
    auto iter = write_reqs.begin();
    size_t batch_size = 10;
    while (iter != write_reqs.end()) {
      Aws::Vector<Aws::DynamoDB::Model::WriteRequest> tmp_reqs;
      for (size_t i = 0; i < batch_size && iter != write_reqs.end(); i++, ++iter) {
        tmp_reqs.push_back(*iter);
      }

      Aws::DynamoDB::Model::BatchWriteItemRequest batch_req;
      batch_req.AddRequestItems(table_name.c_str(), tmp_reqs);
      auto result = dynamodb_client.BatchWriteItem(batch_req);
      if (!result.IsSuccess()) {
        std::cerr << result.GetError().GetMessage() << std::endl;
      }

      // Process throttled items.
      while (result.GetResult().GetUnprocessedItems().size() > 0) {
        batch_req.SetRequestItems(result.GetResult().GetUnprocessedItems());
        result = dynamodb_client.BatchWriteItem(batch_req);
        if (!result.IsSuccess()) {
          std::cerr << result.GetError().GetMessage() << std::endl;
        }
      }
    }
*/
  std::cout << "success batch write items !" << std::endl;
  getchar();
  //----------------------------------------------------------------------------
  {
    // batch get items
     Aws::Map<Aws::String, AttributeValue> item1;
    item1.insert(std::make_pair("id", NumberToAttribute(5)));
    item1.insert(std::make_pair("class", NumberToAttribute(5)));

    Aws::Map<Aws::String, AttributeValue> item2;
    item2.insert(std::make_pair("id", NumberToAttribute(6)));
    item2.insert(std::make_pair("class", NumberToAttribute(6)));

    Aws::DynamoDB::Model::KeysAndAttributes key_attr;
    key_attr.SetExpressionAttributeNames({{"#name", "name"},
                                          {"#class", "class"}});
    key_attr.AddKeys(item1);
    key_attr.AddKeys(item2);

    Aws::StringStream stream;
    stream << "id" << ", " << "#class" << ", " << "#name";
    key_attr.SetProjectionExpression(stream.str());

    Aws::DynamoDB::Model::BatchGetItemRequest batch_request;
    batch_request.AddRequestItems(table.c_str(), key_attr);
    auto result = dynamodb_client.BatchGetItem(batch_request);
    if (!result.IsSuccess()) {
      std::cout << "Fail to batch write item: "
                << result.GetError().GetExceptionName().c_str() << "\n"
                << result.GetError().GetMessage().c_str();
    }
    for (auto response : result.GetResult().GetResponses()) {
      for (auto item : response.second) {
        PrintItem(item);
      }
    }

    // Continue processing throttled items
    while (result.GetResult().GetUnprocessedKeys().size() > 0) {
      batch_request.SetRequestItems(result.GetResult().GetUnprocessedKeys());
      result = dynamodb_client.BatchGetItem(batch_request);
      if (!result.IsSuccess()) {
        std::cout << "Fail to batch write item: "
                  << result.GetError().GetExceptionName().c_str() << "\n"
                  << result.GetError().GetMessage().c_str();
      }
      for (auto response : result.GetResult().GetResponses()) {
        for (auto item : response.second) {
          PrintItem(item);
        }
      }
    }
  }
  std::cout << "success batch get items !" << std::endl;
  getchar();
  //----------------------------------------------------------------------------
    // batch delete
    std::vector<Aws::DynamoDB::Model::WriteRequest> write_reqs;
    Aws::DynamoDB::Model::DeleteRequest delete_req;
    delete_req.SetKey({{"bag_name", AttributeValue("test1.bag")}});
    Aws::DynamoDB::Model::WriteRequest write_req;
    write_req.SetDeleteRequest(delete_req);
    write_reqs.push_back(write_req);

    Aws::DynamoDB::Model::DeleteRequest delete_req2;
    delete_req2.SetKey({{"bag_name", AttributeValue("test2.bag")}});
    Aws::DynamoDB::Model::WriteRequest write_req2;
    write_req2.SetDeleteRequest(delete_req2);
    write_reqs.push_back(write_req2);

    // write
    auto iter = write_reqs.begin();
    size_t batch_size = 10;
    while (iter != write_reqs.end()) {
      Aws::Vector<Aws::DynamoDB::Model::WriteRequest> tmp_reqs;
      for (size_t i = 0; i < batch_size && iter != write_reqs.end(); i++, ++iter) {
        tmp_reqs.push_back(*iter);
      }

      Aws::DynamoDB::Model::BatchWriteItemRequest batch_req;
      batch_req.AddRequestItems(table_name.c_str(), tmp_reqs);
      auto result = dynamodb_client.BatchWriteItem(batch_req);
      if (!result.IsSuccess()) {
        std::cerr << result.GetError().GetMessage() << std::endl;
      }

      // Process throttled items.
      while (result.GetResult().GetUnprocessedItems().size() > 0) {
        batch_req.SetRequestItems(result.GetResult().GetUnprocessedItems());
        result = dynamodb_client.BatchWriteItem(batch_req);
        if (!result.IsSuccess()) {
          std::cerr << result.GetError().GetMessage() << std::endl;
        }
      }
    }
  //----------------------------------------------------------------------------
  Aws::ShutdownAPI(options);
  return 0;
}

CMakeLists.txt:

cmake_minimum_required(VERSION 2.8)
project(aws_dynamodb_test)

set(CMAKE_CXX_STANDARD 14)
set(EXECUTABLE_OUTPUT_PATH ${PROJECT_SOURCE_DIR}/bin)

find_package(AWSSDK REQUIRED)
#include_directories(${AWSSDK_INCLUDE_DIRS})
LINK_DIRECTORIES(/usr/local/lib/)
add_executable(aws_dynamodb_test dynamodb.cc)
target_link_libraries(aws_dynamodb_test
        libaws-cpp-sdk-core.so
        libaws-cpp-sdk-dynamodb.so)

３、s3使用

官方例子：https://docs.amazonaws.cn/sdk-for-cpp/v1/developer-guide/examples-s3.html

s3.cc:

#include <fstream>
#include "aws/core/Aws.h"
#include "aws/core/auth/AWSCredentialsProvider.h"
#include "aws/s3/S3Client.h"
#include "aws/s3/model/HeadBucketRequest.h"
#include "aws/s3/model/ListObjectsRequest.h"
#include "aws/s3/model/HeadObjectRequest.h"
#include "aws/s3/model/DeleteObjectRequest.h"
#include "aws/s3/model/CopyObjectRequest.h"
#include "aws/s3/model/GetObjectRequest.h"
#include "aws/s3/model/PutObjectRequest.h"

std::string bucket = "bucket_name";
std::string directory = "alan_test";
std::string key = "alan_test/1.pcd";
std::string dst_key = "alan_test/3.pcd";

int main() {
  Aws::SDKOptions options;
  // options.loggingOptions.logLevel = Aws::Utils::Logging::LogLevel::Trace;
  Aws::InitAPI(options);

  Aws::Auth::AWSCredentials credentials("access key", "secret key");
  Aws::Client::ClientConfiguration client_config;
  client_config.region = "cn-northwest-1";
  client_config.requestTimeoutMs = 300000;
  //  client_config.endpointOverride = "localhost:8000";
  //  client_config.scheme = Aws::Http::Scheme::HTTP;
  //  client_config.endpointOverride = "10.202.91.2:88";  // s3服务器地址和端口
  //  client_config.verifySSL = false;
  Aws::S3::S3Client s3_client(credentials, client_config);
  std::cout << "success initial !" << std::endl;
  getchar();
  //----------------------------------------------------------------------------
  {
    // list buckets
    auto result = s3_client.ListBuckets();
    if (!result.IsSuccess()) {
      std::cout << "Fail to list buckets "
                << result.GetError().GetExceptionName().c_str() << "\n"
                << result.GetError().GetMessage().c_str();
    }
    auto buckets = result.GetResult().GetBuckets();
    for (auto bucket : buckets) {
      std::cout << "bucket: " << bucket.GetName() << "\t"
                << bucket.GetCreationDate().ToLocalTimeString(Aws::Utils::DateFormat::ISO_8601) << std::endl;
    }
  }
  std::cout << "success list buckets !" << std::endl;
  getchar();
  //----------------------------------------------------------------------------
  {
    // check bucket exist
    Aws::S3::Model::HeadBucketRequest request;
    request.WithBucket(bucket.c_str());
    auto result = s3_client.HeadBucket(request);
    if (result.IsSuccess()) {
      std::cout << "bucket: " << bucket << " exist !" << std::endl;
    } else {
      std::cout << "Fail to open bucket: " << bucket.c_str() << ": "
                << result.GetError().GetExceptionName().c_str() << "\n"
                << result.GetError().GetMessage().c_str();
    }
//    Aws::Http::HttpMethod method = Aws::Http::HttpMethod::HTTP_GET; // Aws::Http::HttpMethod::HTTP_HEAD
//    auto url = s3_client.GeneratePresignedUrl(Aws::String(bucket.c_str()),
//                                              Aws::String(key.c_str()), method,
//                                              expiration_in_seconds_);
  }
  std::cout << "success check bucket exist !" << std::endl;
  getchar();
  //----------------------------------------------------------------------------
  {
    // list object
    Aws::S3::Model::ListObjectsRequest request;
    request.WithBucket(bucket.c_str()).WithPrefix(directory.c_str());
    auto result = s3_client.ListObjects(request);
    if (!result.IsSuccess()) {
      std::cout << "Fail to list bucket direct "
                << result.GetError().GetExceptionName().c_str() << "\n"
                << result.GetError().GetMessage().c_str();
    }
    for (auto object : result.GetResult().GetContents()) {
      std::cout << "key: " << object.GetKey().c_str() << std::endl;
    }
  }
  std::cout << "success list object !" << std::endl;
  getchar();
  //----------------------------------------------------------------------------
  {
    // check key exists
    Aws::S3::Model::HeadObjectRequest request;
    request.WithBucket(bucket.c_str()).WithKey(key.c_str());
    auto result = s3_client.HeadObject(request);
    if (result.IsSuccess()) {
      std::cout << "key: " << key << " exist !" << std::endl;
    } else if (result.GetError().GetErrorType() == Aws::S3::S3Errors::RESOURCE_NOT_FOUND) {
      std::cout << "key: " << key << " no exist !" << std::endl;
    } else {
      std::cout << "Error checking existence !\n"
                << "key: " << key << "\n"
                << "error: " << result.GetError().GetMessage().c_str();
    }
  }
  std::cout << "success check key exist !" << std::endl;
  getchar();
  //----------------------------------------------------------------------------
  {
    // delete object
    Aws::S3::Model::DeleteObjectRequest request;
    request.WithBucket(bucket.c_str()).WithKey(dst_key.c_str());
    auto result = s3_client.DeleteObject(request);
    if (result.IsSuccess()) {
      std::cout << "success delete object: " << dst_key << std::endl;
    } else {
      std::cout << "fail to delete object: " << dst_key << std::endl;
    }
  }
  std::cout << "success delete object !" << std::endl;
  getchar();
  //----------------------------------------------------------------------------
  {
    // copy object
    Aws::S3::Model::CopyObjectRequest request;
    request.WithBucket(bucket.c_str())
           .WithKey((dst_key).c_str())
           .WithCopySource((bucket + "/" + key).c_str());
    auto result = s3_client.CopyObject(request);
    if (result.IsSuccess()) {
      std::cout << "success copy object: " << key << " --> " << dst_key << std::endl;
    } else {
      std::cout << "fail to copy object: " << key << " --> " << dst_key << std::endl;
    }
  }
  std::cout << "success copy object !" << std::endl;
  getchar();
  //----------------------------------------------------------------------------
  {
    // get object
    std::string aws_key = "alan_test/1.pcd";
    std::string local_path = "/tmp/local.pcd";
    Aws::S3::Model::GetObjectRequest request;
    request.WithBucket(bucket.c_str()).WithKey(aws_key.c_str());
    // request.SetBucket(bucket.c_str());
    // request.SetKey(aws_key.c_str());

int retry = 3;
for (size_t i = 0; i < retry; ++i) {
    auto result = s3_client.GetObject(request); // Aws::S3::Model::GetObjectOutcome
    if (result.IsSuccess()) {
      std::cout << "success get object: "
                << bucket + "/" + aws_key << " --> " << local_path << std::endl;
      std::ofstream fout(local_path.c_str());
      fout.exceptions(std::ifstream::failbit | std::ifstream::badbit);
      fout << result.GetResult().GetBody().rdbuf();
      fout.close();
      // std::stringstream ss;
      // Aws::IOStream& string_file = result.GetResultWithOwnership().GetBody();
      // ss << string_file.rdbuf();
      break;
    } else {
      std::cout << "Fail to get object "
                << result.GetError().GetExceptionName().c_str() << "\n"
                << result.GetError().GetMessage().c_str();
    }
}

  }
  std::cout << "success get object !" << std::endl;
  getchar();
  //----------------------------------------------------------------------------
  {
    // put object
    std::string local_path = "/tmp/local.pcd";
    std::string aws_key = "alan_test/4.pcd";
    Aws::S3::Model::PutObjectRequest request;
    request.WithBucket(bucket.c_str()).WithKey(aws_key.c_str());
    auto input_string = Aws::MakeShared<Aws::FStream>(
            "PutObjectInputStream", local_path.c_str());
    request.SetBody(input_string);
    auto result = s3_client.PutObject(request);
    if (result.IsSuccess()) {
      std::cout << "success put object: "
                << local_path << " --> " << bucket + "/" + aws_key << std::endl;
    } else {
      std::cout << "Fail to put object "
                << result.GetError().GetExceptionName().c_str() << "\n"
                << result.GetError().GetMessage().c_str();
    }
  }
  std::cout << "success put object !" << std::endl;
  getchar();
  //----------------------------------------------------------------------------
  Aws::ShutdownAPI(options);
  return 0;
}

CMakeLists.txt:

cmake_minimum_required(VERSION 2.8)
project(aws_s3_test)

set(CMAKE_CXX_STANDARD 14)
set(EXECUTABLE_OUTPUT_PATH ${PROJECT_SOURCE_DIR}/bin)

find_package(AWSSDK REQUIRED)
#include_directories(${AWSSDK_INCLUDE_DIRS})
LINK_DIRECTORIES(/usr/local/lib/)
add_executable(aws_s3_test s3.cc)
target_link_libraries(aws_s3_test
        libaws-cpp-sdk-core.so
        libaws-cpp-sdk-s3.so)

4、sqs使用

官方例子：https://docs.amazonaws.cn/sdk-for-cpp/v1/developer-guide/examples-sqs.html

sqs.cc:

#include <iostream>
#include "aws/core/Aws.h"
#include "aws/core/auth/AWSCredentialsProvider.h"
#include "aws/core/utils/Outcome.h"
#include "aws/sqs/SQSClient.h"
#include <aws/sqs/model/ListQueuesRequest.h>
#include <aws/sqs/model/ListQueuesResult.h>
#include <aws/sqs/model/CreateQueueRequest.h>
#include <aws/sqs/model/CreateQueueResult.h>
#include <aws/sqs/model/GetQueueUrlRequest.h>
#include <aws/sqs/model/GetQueueUrlResult.h>
#include <aws/sqs/model/SendMessageRequest.h>
#include <aws/sqs/model/SendMessageResult.h>
#include <aws/sqs/model/ReceiveMessageRequest.h>
#include <aws/sqs/model/ReceiveMessageResult.h>
#include <aws/sqs/model/DeleteMessageRequest.h>
#include <aws/sqs/model/DeleteQueueRequest.h>

std::string queue_name = "alan_test";
std::string queue_url;

int main() {
  Aws::SDKOptions options;
  // options.loggingOptions.logLevel = Aws::Utils::Logging::LogLevel::Trace;
  Aws::InitAPI(options);

  Aws::Auth::AWSCredentials credentials("access key", "secret key");
  Aws::Client::ClientConfiguration client_config;
  client_config.region = "cn-northwest-1";
  client_config.requestTimeoutMs = 300000;
  //  client_config.endpointOverride = "localhost:8000";
  //  client_config.scheme = Aws::Http::Scheme::HTTP;
  //  client_config.endpointOverride = "10.202.91.2:88";  // sqs服务器地址和端口
  //  client_config.verifySSL = false;
  Aws::SQS::SQSClient sqs_client(credentials, client_config);
  std::cout << "success initial !" << std::endl;
  getchar();
  //-----------------------------------------------------------------------------
  {
    // list queue
    Aws::SQS::Model::ListQueuesRequest lq_req;
    auto lq_out = sqs_client.ListQueues(lq_req);
    if (lq_out.IsSuccess()) {
      std::cout << "Queue Urls:" << std::endl;
      const auto &queue_urls = lq_out.GetResult().GetQueueUrls();
      for (const auto &iter : queue_urls) {
        std::cout << " " << iter << std::endl;
      }
    } else {
      std::cout << "Error listing queues: " << lq_out.GetError().GetMessage() << std::endl;
    }
  }
  getchar();
  //----------------------------------------------------------------------------
  {
    // create queue
    Aws::SQS::Model::CreateQueueRequest cq_req;
    cq_req.SetQueueName(queue_name.c_str());
    auto cq_out = sqs_client.CreateQueue(cq_req);
    if (cq_out.IsSuccess()) {
      std::cout << "Successfully created queue " << queue_name << std::endl;
    } else {
      std::cout << "Error creating queue " << queue_name << ": "
                << cq_out.GetError().GetMessage() << std::endl;
    }
  }
  getchar();
  //----------------------------------------------------------------------------
  {
    // // get queue url
    Aws::SQS::Model::GetQueueUrlRequest gqu_req;
    gqu_req.SetQueueName(queue_name.c_str());
    auto gqu_out = sqs_client.GetQueueUrl(gqu_req);
    if (gqu_out.IsSuccess()) {
      queue_url = gqu_out.GetResult().GetQueueUrl().c_str();
      std::cout << "Queue " << queue_name << " has url " << queue_url << std::endl;
    } else {
      std::cout << "Error getting url for queue " << queue_name << ": "
                << gqu_out.GetError().GetMessage() << std::endl;
    }
  }
  getchar();
  //----------------------------------------------------------------------------
  {
    // send message
    std::string msg_body = "hello, world !";
    Aws::SQS::Model::SendMessageRequest sm_req;
    sm_req.SetQueueUrl(queue_url.c_str());
    sm_req.SetMessageBody(msg_body.c_str());
    auto sm_out = sqs_client.SendMessage(sm_req);
    if (sm_out.IsSuccess()) {
      std::cout << "Successfully sent message to " << queue_url << std::endl;
    } else {
      std::cout << "Error sending message to " << queue_url << ": "
                << sm_out.GetError().GetMessage() << std::endl;
    }
  }
  getchar();
  //----------------------------------------------------------------------------
  Aws::SQS::Model::Message message;
  {
    // receive message
    Aws::SQS::Model::ReceiveMessageRequest rm_req;
    rm_req.SetQueueUrl(queue_url.c_str());
    rm_req.SetMaxNumberOfMessages(1);
    auto rm_out = sqs_client.ReceiveMessage(rm_req);
    if (rm_out.IsSuccess()) {
      const auto& messages = rm_out.GetResult().GetMessages();
      if (messages.size() == 0) {
        std::cout << "No messages received from queue " << queue_url << std::endl;
      } else {
        message = messages[0];
        std::cout << "Received message:" << std::endl;
        std::cout << "  MessageId: " << message.GetMessageId() << std::endl;
        std::cout << "  ReceiptHandle: " << message.GetReceiptHandle() << std::endl;
        std::cout << "  Body: " << message.GetBody() << std::endl << std::endl;
      }
    } else {
      std::cout << "Error receiving message from queue " << queue_url << ": "
                << rm_out.GetError().GetMessage() << std::endl;
    }
  }
  getchar();
  //----------------------------------------------------------------------------
  {
    // delete message
    Aws::SQS::Model::DeleteMessageRequest dm_req;
    dm_req.SetQueueUrl(queue_url.c_str());
    dm_req.SetReceiptHandle(message.GetReceiptHandle());
    auto dm_out = sqs_client.DeleteMessage(dm_req);
    if (dm_out.IsSuccess()) {
      std::cout << "Successfully deleted message " << message.GetMessageId()
                << " from queue " << queue_url << std::endl;
    } else {
      std::cout << "Error deleting message " << message.GetMessageId() << " from queue " << queue_url
                << ": " << dm_out.GetError().GetMessage() << std::endl;
    }
  }
  getchar();
  //----------------------------------------------------------------------------
  {
    // delete queue
    Aws::SQS::Model::DeleteQueueRequest dq_req;
    dq_req.SetQueueUrl(queue_url.c_str());
    auto dq_out = sqs_client.DeleteQueue(dq_req);
    if (dq_out.IsSuccess()) {
      std::cout << "Successfully deleted queue with url " << queue_url << std::endl;
    } else {
      std::cout << "Error deleting queue " << queue_url << ": "
                << dq_out.GetError().GetMessage() << std::endl;
    }
  }
  getchar();
  //----------------------------------------------------------------------------
  Aws::ShutdownAPI(options);
  return 0;
}

 CMakeLists.txt:

cmake_minimum_required(VERSION 2.8)
project(aws_sqs_test)

set(CMAKE_CXX_STANDARD 14)
set(EXECUTABLE_OUTPUT_PATH ${PROJECT_SOURCE_DIR}/bin)

find_package(AWSSDK REQUIRED)
#include_directories(${AWSSDK_INCLUDE_DIRS})
LINK_DIRECTORIES(/usr/local/lib/)
add_executable(aws_sqs_test sqs.cc)
target_link_libraries(aws_sqs_test
        libaws-cpp-sdk-core.so
        libaws-cpp-sdk-sqs.so)

参考：

https://docs.aws.amazon.com/ko_kr/sdk-for-cpp/v1/developer-guide/build-cmake.html

https://aws.amazon.com/blogs/developer/using-cmake-exports-with-the-aws-sdk-for-c/

https://aws.amazon.com/blogs/developer/developer-experience-of-the-aws-sdk-for-c-now-simplified-by-cmake/

https://docs.aws.amazon.com/

Amazon DynamoDB 入门

开发人员指南

API Reference

Alan Lan
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
VS2017编译通过的aws-sdk-cpp工程代码
01-18
aws-sdk-cpp 1.9.26 C++ SDK 附带生成好的vs2017解决方案和工程文件，使用有问题请留言
Windows下Qt使用AWS SDK for C++连接MinIO服务器
qq_23604781的博客
12-11 1485
Windows下Qt使用AWS SDK for C++连接MinIO服务器
MINIO服务器基于AWS S3 SDK 文件分片上传及下载（C++实现）
weixin_43482623的博客
11-14 1083
【代码】MINIO服务器基于AWS S3 SDK 文件分片上传及下载（C++实现）
ubuntu16.04编译aws-sdk-cpp
skl5879166的博客
11-18 1217
1 从git上下载源码 git clone --recurse-submodules https://github.com/aws/aws-sdk-cpp 2 安装依赖包 apt-get install -y g++ apt-get install -y cmake apt-get install -y libssl-dev apt-get install -y libcurl4-openssl-dev apt-get install -y uuid-dev apt-get install -y
编译使用Aws-cpp-sdk API
pluto_rx的博客
07-20 2669
在Linux系统上使用aws-cpp-sdk源码进行编译开发。操作系统使用原生的contos7Linux。
aws-sdk-cpp：适用于C ++的AWS开发工具包
01-30
适用于C ++的AWS开发工具包 适用于C ++的AWS开发工具包为Amazon Web Services（AWS）提供了现代C ++（C ++ 11或更高版本）接口。 它旨在在低级和高级SDK上实现高性能并完全起作用，同时最大限度地减少依赖性并提供平台可移植性（Windows，OSX，Linux和移动设备）。 适用于C ++的AWS开发工具包现已提供一般可用性，建议用于生产环境。 我们邀请客户通过提交请求并通过GitHub Issues向我们发送反馈和想法来参与开发工作。 版本1.8现在可用！ 1.8版引入了对新功能和SDK进行更改的要求很高的功能，但是由于这也可能导致与以前版本的兼容性问题，我们决定将其保留为单独的分支，以减少过渡的麻烦。 有关更多信息，请参阅Wiki的条目，还请提供您对固定的这些更改的任何反馈。 跳到： 入门 构建SDK： 最低要求： Visual Studio 2015或更高版本 或GNU编译器集合（GCC）4.9或更高版本 或Clang 3.3或更高版本 4GB RAM 建立一些较大的客户端需要4GB的RAM。 由于内存不足，在EC2实例类型t2.m
windows环境下编译aws-sdk-cpp踩坑记
Bruce Che 的专栏
06-02 1617
在做图片、视频片段存储技术调研时，从查阅的大量资料中，了解到很多人推荐的开源MinIO，其优点简单来说易于部署和调用，支持高可靠性等，但是官方却没提供C++版本的API接口，这点对C++开发人员不友好。好在它是遵循亚马逊S3协议的，所以可以通过调用aws-sdk-cpp对MinIO访问。下边记录了笔者编译aws-sdk-cpp碰到的一些坑以及解决办法，供有需要的朋友参考，以少走弯路。
使用cmake配置aws-cpp-sdk以及在cmake项目中使用
xzq1207105685的博客
02-26 2755
目录环境配置cmake编译aws-cpp-sdk1.使用git bash下载aws-cpp-sdk项目到指定目录2. 使用clion打开项目3. 设置cmake编译选项4. BUILD&&INSTALL 项目在cmake项目中使用aws-cpp-sdk配置CMakeLists.txt编译和项目构建中坑fatal error C1083: Cannot open include file: 'unistd.h'【解决方案】find_package(AWSSDK REQUIRED)找不到【错误描
Ubuntu 18.04 编译 aws-sdk-cpp
Tonyfield的专栏
03-17 803
主要参考 https://docs.aws.amazon.com/sdk-for-cpp/v1/developer-guide/aws-sdk-cpp-dg.pdf#welcome 就好了 通过国内镜像克隆 git clone https://github.com.cnpmjs.org/aws/aws-sdk-cpp.git 压缩备份 tar zcvf aws-sdk-cpp.git.tar.gz aws-sdk-cpp/ 修改源文件中 github到国内镜像站点 cd aws-sdk-c
aws-sdk-cpp通过bazel构建的S3_client轮子
permi_yaxileni的博客
12-25 946
官网第7步 make install后，默认路径是/use/local/lib（指定路径了当我没说）目录下存在两个通过官网流程编译的最新的动态链接库libaws-cpp-sdk-core.so，libaws-cpp-sdk-s3.so。很多工业界正在使用的东西学校都不会教，都需要有空的时候自己学学，比如git，linux使用，docker，bazel等等。没什么办法，上班了之后做的很多东西都是调用api，越来越像一个工具人了，虽然说本身也大差不差的。看来没有现成的，留给我的只有官网一条路了，通过源码编译。
libs3:A C Library API for Amazon S3
04-19
amazon S3的C语言接口库，不用开发者重新开发与amazon的http连接接口
aws-sdk-perl：适用于Perl程序员的社区AWS开发工具包
02-01
aws-sdk-perl：适用于Perl程序员的社区AWS开发工具包
aws-sdk-php-zf2:ZF2模块，用于使用适用于PHP的AWS开发工具包与AWS服务交互，例如S3，DynamoDB，SQS，EC2等
05-28
如果要使用ZF3并且您PHP版本> = 5.6，请使用{ " require " : { " aws/aws-sdk-php-zf2 " : " 4.* " }} 除此以外， { " require " : { " aws/aws-sdk-php-zf2 " : " 3.* " }} 如果您使用的ZF2服务管理器<...
terraform-aws-lambda：用于创建AWS Lambda资源的Terraform模块
02-04
terraform-aws-lambda：用于创建AWS Lambda资源的Terraform模块
dynamo-to-sqs-aws-data-pipeline:AWS Data Pipeline从dynamodb读取数据并将内容发送到sqs
04-06
dynamo到sqs-aws数据管道 AWS Data Pipeline从dynamodb读取数据并将内容发送到sqs
如何定义AWS DynamoDB的客户端？
yuanshine的博客
07-10 346
namespace Auth = Aws::Auth; namespace AWSCredentials = Auth::AWSCredentials; namesapce Client = Aws::Client; namespace ClientConfiguration = Client::ClientConfiguration; namespace DynamoDB = Aws::Dyn...
Ubuntu云服务部署MiniO && AWS-SDK-CPP访问MiniO
Tenderoy的博客
01-06 1378
腾讯云Ubuntu部署MiniO，通过aws-sdk-cpp访问MiniO
ubuntu编译安装aws-sdk-cpp
最新发布
maogeweiwu的博客
01-09 1088
minio是一款开源的对象存储服务器，用了存储和下载文件;；github:注：(1) 目前已测试架构：x86(PC机)和aarch64(xavier盒子和ajx盒子)(2) 目前已测试ubuntu版本： 16、18、20、22(3) 由于我们主要目的是用C++调用minio接口，因此这里仅需要将core和s3编译成功即可，不强求全部编译通过。
使用C++ AWS SDK的CurlHttpClient
夜雨悠扬 的专栏
11-03 438
C++ AWS SDK CurlHttpClient
Visual Studio aws-sdk-s3 c++ minio
06-03
你的问题是关于在 Visual Studio 中使用 aws-sdk-s3 和 Minio 的 C++ 库的问题。我可以给你一些指导。 首先，你需要下载和安装 aws-sdk-cpp 和 Minio C++ 库。然后，你需要在 Visual Studio 中创建一个 C++ 项目，并将这些库添加到项目中。你可以在项目属性中的“VC++ 目录”和“链接器”部分中添加库的路径和名称。 接下来，你需要在代码中包含库的头文件，并使用它们提供的 API 来编写你的程序。对于 aws-sdk-s3，你需要设置 AWS 认证信息并连接到 S3 存储桶。对于 Minio，你需要设置 Minio 的认证信息并连接到 Minio 服务器。 最后，你可以编译和运行你的程序来测试它是否正常工作。如果遇到问题，你可以查看库的文档和示例代码，或者在相关的论坛或社区中寻求帮助。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值