How to Upload a File to DigitalOcean Spaces Using AWS C++ SDK

The AWS C++ SDK offers several advantages when working with DigitalOcean Spaces. Some of the key benefits include:

• Provides a high-level interface for interacting with DigitalOcean Spaces, making it easier to manage your cloud storage.
• Offers a consistent programming model across different AWS services, reducing the learning curve for developers.
• Enables seamless integration with other AWS services, allowing for a more comprehensive cloud-based solution.

When choosing a tool for interacting with DigitalOcean Spaces, it’s essential to consider the unique features and benefits of each option. Here’s how the AWS C++ SDK compares to other tools:

• Offers a native C++ interface, which may be more familiar and comfortable for C++ developers.
• Provides a more integrated development experience, as it can be used alongside other AWS services in the same codebase.
• Supports a wide range of AWS services, making it an ideal choice for developers who need to work with multiple AWS services.

We will use following tools for this tutorial:

• CMake (≥ 3.13) - A cross-platform build system generator that manages the build process using simple configuration files (CMakeLists.txt).
• GCC / Clang - Popular C++ compilers used to translate source code into executable programs across various platforms.
• AWS C++ SDK
• A DigitalOcean Spaces bucket
• Your Spaces Access Key and Secret
• A file to upload

Project Structure

Demonstrating the folder structure for better understanding of the code in use:

do\_spaces\_cpp/  
├── build/  
├── CMakeLists.txt  
├── main.cpp  → C++ source code  
└── example.txt  → file to upload

1. Install AWS C++ SDK

You can follow the official guide: https://github.com/aws/aws-sdk-cpp

Or, run the following commands to install the AWS C++ SDK:

git clone --recurse-submodules https://github.com/aws/aws-sdk-cpp.git
cd aws-sdk-cpp
mkdir build && cd build
cmake .. -DCMAKE_BUILD_TYPE=Release -DBUILD_ONLY="s3"
make -j4
sudo make install

2. Create main.cpp

Here’s a minimal working example code for uploading example.txt to DigitalOcean Spaces bucket:

#include <aws/core/Aws.h>
#include <aws/core/auth/AWSCredentialsProvider.h>
#include <aws/core/client/ClientConfiguration.h>
#include <aws/core/utils/memory/stl/AWSStringStream.h>
#include <aws/s3/S3Client.h>
#include <aws/s3/model/PutObjectRequest.h>
#include <fstream>
#include <iostream>

int main() {
    Aws::SDKOptions options;
    Aws::InitAPI(options);
    {
        // Replace with your actual credentials
        const Aws::String access_key = "<your-access-key>";
        const Aws::String secret_key = "<your-secret-key>";

        // Bucket name and endpoint
        const Aws::String bucket_name = "bucket name only";
        const Aws::String object_key = "example.txt"; // object name in spaces
        const Aws::String file_name = "example.txt";  // local file to upload
        const Aws::String endpoint = "blr1.digitaloceanspaces.com";
        const Aws::String region = "us-east-1";  // Use this for DO Spaces

        Aws::Auth::AWSCredentials credentials(access_key, secret_key);

        Aws::Client::ClientConfiguration config;
        config.endpointOverride = endpoint;
        config.region = region;
        config.scheme = Aws::Http::Scheme::HTTPS;

        // Create S3 client with path-style addressing
        Aws::S3::S3Client s3_client(
            Aws::MakeShared<Aws::Auth::SimpleAWSCredentialsProvider>("cred-tag", credentials),
            config,
            Aws::Client::AWSAuthV4Signer::PayloadSigningPolicy::Always,
            false  // Disable virtual addressing for DO Spaces
        );

        Aws::S3::Model::PutObjectRequest request;
        request.SetBucket(bucket_name);
        request.SetKey(object_key);
        request.SetContentType("text/plain");

        // Read the local file
        auto input_data = Aws::MakeShared<Aws::FStream>("FileTag",
            file_name.c_str(), std::ios_base::in | std::ios_base::binary);

        if (!input_data->good()) {
            std::cerr << "Failed to open file: " << file_name << std::endl;
            Aws::ShutdownAPI(options);
            return 1;
        }

        request.SetBody(input_data);

        auto outcome = s3_client.PutObject(request);

        if (outcome.IsSuccess()) {
            std::cout << "Upload successful: " << object_key << std::endl;
        } else {
            std::cerr << "Upload failed!" << std::endl;
            std::cerr << "Error: " << outcome.GetError().GetExceptionName()
                      << " - " << outcome.GetError().GetMessage() << std::endl;
        }
    }
    Aws::ShutdownAPI(options);
    return 0;
}

• Replace <your-access-key>, <your-secret-key>, and <your-bucket-name> with your actual credentials.
• Replace blr1.digitaloceanspaces.com with the endpoint of your region.
• DigitalOcean Spaces doesn’t require region-specific configuration like AWS. You can use us-east-1 as a dummy region.

3. CMakeLists.txt

The CMakeLists.txt file is used by CMake to configure and build your C++ project. Here’s what each line does in this context:

cmake_minimum_required(VERSION 3.16)  # Specifies the minimum version of CMake required to build the project.
project(do_spaces_cpp)  # Sets the project name to do_spaces_cpp.
set(CMAKE_CXX_STANDARD 17)  # Sets the C++ standard to use for the project to C++17.
find_package(AWSSDK REQUIRED COMPONENTS s3)  # Finds the AWS SDK package and requires the S3 component.
add_executable(do_spaces_cpp main.cpp)  # Adds an executable target named do_spaces_cpp that is built from main.cpp.
target_link_libraries(do_spaces_cpp ${AWSSDK_LINK_LIBRARIES})  # Links the do_spaces_cpp executable to the AWS SDK libraries.

4. Build the Project using CMake (VS Code)

Install CMake Tools extension.
Open Command Palette → CMake: Configure
Then → CMake: Build

Make sure your example.txt file is in the root project directory, not build/.

Run the program from your terminal:

cd build
./do_spaces_cpp

This will upload the file to your DigitalOcean Spaces bucket and you should see: Successfully uploaded example.txt

• Never commit your keys to GitHub or any other version control system. This is crucial to prevent unauthorized access to your DigitalOcean Spaces account. Hardcoding or committing your access keys can lead to security breaches and compromise your data.
• Store them in .env or a config file and load programmatically. This approach ensures that your access keys are not directly embedded in your codebase. Instead, they are stored in a separate file that is not committed to your repository. This way, you can manage access to your keys more securely and easily rotate them if needed.
• Assign only the minimum permissions required for your access key. When creating an access key, ensure that it has the least privileges necessary to perform the required actions. This principle of least privilege helps limit the damage in case your access key is compromised. It’s essential to regularly review and update the permissions associated with your access keys to maintain optimal security.

1. How do I handle errors when uploading a file to DigitalOcean Spaces using the AWS C++ SDK?

Error handling is crucial when working with the AWS C++ SDK to ensure that your application can gracefully handle any errors that might occur during the file upload process. Here’s an example of how you can handle errors using the Aws::S3::S3Client and Aws::S3::Model::PutObjectRequest:

Aws::S3::S3Client s3Client;
Aws::S3::Model::PutObjectRequest putObjectRequest;
putObjectRequest.SetBucket("your-bucket-name");
putObjectRequest.SetKey("example.txt");
putObjectRequest.SetBody("example.txt", "Hello, World!");

Aws::S3::Model::PutObjectOutcome putObjectOutcome = s3Client.PutObject(putObjectRequest);
if (!putObjectOutcome.IsSuccess()) {
    std::cerr << "Failed to upload file: " << putObjectOutcome.GetError().GetExceptionName()
              << " - " << putObjectOutcome.GetError().GetMessage() << std::endl;
} else {
    std::cout << "Successfully uploaded example.txt" << std::endl;
}

In this example, we use the PutObjectOutcome object to check if the upload was successful. If not, we log the error details to the standard error stream.

2. Can I use the AWS C++ SDK to list files in my DigitalOcean Spaces bucket?

Yes, you can use the AWS C++ SDK to list files in your DigitalOcean Spaces bucket. Here’s an example of how to do it using the Aws::S3::S3Client and Aws::S3::Model::ListObjectsRequest:

Aws::S3::S3Client s3Client;
Aws::S3::Model::ListObjectsRequest listObjectsRequest;
listObjectsRequest.SetBucket("your-bucket-name");

Aws::S3::Model::ListObjectsOutcome listObjectsOutcome = s3Client.ListObjects(listObjectsRequest);
if (!listObjectsOutcome.IsSuccess()) {
    std::cerr << "Failed to list objects: " << listObjectsOutcome.GetError().GetExceptionName()
              << " - " << listObjectsOutcome.GetError().GetMessage() << std::endl;
} else {
    for (const auto& object : listObjectsOutcome.GetResult().GetContents()) {
        std::cout << "Object: " << object.GetKey() << std::endl;
    }
}

In this example, we use the ListObjectsOutcome object to check if the list operation was successful. If not, we log the error details to the standard error stream. If successful, we iterate over the list of objects and print their keys to the standard output stream.

3. How do I specify the region for my DigitalOcean Spaces bucket using the AWS C++ SDK?

To specify the region for your DigitalOcean Spaces bucket using the AWS C++ SDK, you need to configure the Aws::Client::ClientConfiguration object before creating the Aws::S3::S3Client instance. Here’s an example:

Aws::Client::ClientConfiguration clientConfig;
clientConfig.region = "us-east-1"; // Replace with your region
Aws::S3::S3Client s3Client(clientConfig);

In this example, we set the region to “us-east-1”, but you should replace it with the actual region where your DigitalOcean Spaces bucket is located.

4. Can I use the AWS C++ SDK to delete files from my DigitalOcean Spaces bucket?

Yes, you can use the AWS C++ SDK to delete files from your DigitalOcean Spaces bucket. Here’s an example of how to do it using the Aws::S3::S3Client and Aws::S3::Model::DeleteObjectRequest:

Aws::S3::S3Client s3Client;
Aws::S3::Model::DeleteObjectRequest deleteObjectRequest;
deleteObjectRequest.SetBucket("your-bucket-name");
deleteObjectRequest.SetKey("example.txt");

Aws::S3::Model::DeleteObjectOutcome deleteObjectOutcome = s3Client.DeleteObject(deleteObjectRequest);
if (!deleteObjectOutcome.IsSuccess()) {
    std::cerr << "Failed to delete file: " << deleteObjectOutcome.GetError().GetExceptionName()
              << " - " << deleteObjectOutcome.GetError().GetMessage() << std::endl;
} else {
    std::cout << "Successfully deleted example.txt" << std::endl;
}

In this example, we use the DeleteObjectOutcome object to check if the deletion was successful. If not, we log the error details to the standard error stream.

5. How do I handle credentials for my DigitalOcean Spaces bucket using the AWS C++ SDK?

To handle credentials for your DigitalOcean Spaces bucket using the AWS C++ SDK, you need to configure the Aws::Auth::AWSCredentialsProviderChain object before creating the Aws::S3::S3Client instance. Here’s an example:

Aws::Auth::AWSCredentialsProviderChain credentialsProvider;
credentialsProvider.Append(Aws::MakeShared<Aws::Auth::EnvironmentAWSCredentialsProvider>("EnvironmentAWSCredentialsProvider"));
credentialsProvider.Append(Aws::MakeShared<Aws::Auth::ProfileConfigFileAWSCredentialsProvider>("ProfileConfigFileAWSCredentialsProvider", "", "default"));

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

Congratulations on successfully uploading a file to DigitalOcean Spaces using the AWS C++ SDK! This achievement marks a significant milestone in your project, as it enables you to automate file uploads, manage cloud backups, or integrate storage with C++ applications. The combination of CMake and VS Code in your toolkit will further streamline the process of building and scaling your project, ensuring a smoother development experience.

By leveraging the AWS C++ SDK for DigitalOcean Spaces, you can now focus on developing more advanced features, such as file management, data processing, and analytics, all while benefiting from the scalability and reliability of cloud storage. This integration also opens up opportunities for creating more sophisticated applications that can seamlessly interact with cloud services, enhancing their overall functionality and user experience.

As you move forward with your project, remember to explore the full range of capabilities offered by the AWS C++ SDK and DigitalOcean Spaces. From handling credentials and managing access to optimizing performance and ensuring data integrity, there are numerous aspects to consider when working with cloud storage. By mastering these concepts, you will be well-equipped to tackle complex challenges and create robust, cloud-enabled applications that meet the evolving needs of your users.

Next steps? Try listing files, deleting them, or downloading from Spaces!

Want to learn more about DigitalOcean Spaces? Check out these helpful tutorials:

• 12 Days of DigitalOcean (Day 10) - Saving Attachments to DigitalOcean Spaces

• How to Create a Spaces Bucket | DigitalOcean Documentation

• How to Use DigitalOcean Spaces Bucket as Tiered Storage in ClickHouse

• AWS SDK Github
• AWS SDK for C++ Documentation
• Spaces API Reference Documentation
• VS Code C++ Guide