C++에서 Google Cloud Storage API를 사용한 대용량 파일 업로드 방법

export GOOGLE_APPLICATION_CREDENTIALS="/path/to/service-account-file.json"

set GOOGLE_APPLICATION_CREDENTIALS=C:\path\to\service-account-file.json

sudo apt update
sudo apt install -y cmake g++ curl unzip \
  libssl-dev libcurl4-openssl-dev \
  libprotobuf-dev protobuf-compiler

git clone https://github.com/googleapis/google-cloud-cpp.git
cd google-cloud-cpp
mkdir build && cd build
cmake .. -DBUILD_SHARED_LIBS=YES -DCMAKE_BUILD_TYPE=Release
make -j$(nproc)
sudo make install

cmake_minimum_required(VERSION 3.10)
project(GCSExample)

find_package(google_cloud_storage REQUIRED)

add_executable(upload_example upload_example.cpp)
target_link_libraries(upload_example google-cloud-cpp::storage)

export GOOGLE_APPLICATION_CREDENTIALS="/path/to/service-account-file.json"

#include <google/cloud/storage/client.h>
#include <iostream>
#include <fstream>
#include <string>

void UploadFile(const std::string& bucket_name, 
                const std::string& file_path, 
                const std::string& object_name) {
    namespace gcs = google::cloud::storage;

    // Google Cloud Storage 클라이언트 생성
    auto client = gcs::Client::CreateDefaultClient().value();

    // 파일을 열고 바이너리 모드로 읽기
    std::ifstream file(file_path, std::ios::binary);
    if (!file) {
        std::cerr << "파일을 열 수 없습니다: " << file_path << std::endl;
        return;
    }

    // 업로드 요청 실행
    auto writer = client.WriteObject(bucket_name, object_name);
    writer << file.rdbuf();  // 파일 내용을 스트림으로 전달
    writer.Close();

    if (!writer.metadata()) {
        std::cerr << "파일 업로드 실패: " << writer.metadata().status() << std::endl;
    } else {
        std::cout << "파일 업로드 성공: " << writer.metadata()->name() << std::endl;
    }
}

int main(int argc, char* argv[]) {
    if (argc != 4) {
        std::cerr << "사용법: " << argv[0] << " <버킷 이름> <파일 경로> <객체 이름>" << std::endl;
        return 1;
    }

    std::string bucket_name = argv[1];
    std::string file_path = argv[2];
    std::string object_name = argv[3];

    UploadFile(bucket_name, file_path, object_name);
    return 0;
}

g++ -std=c++17 upload_example.cpp -o upload_example \
    -lgoogle_cloud_cpp_storage -lgoogle_cloud_cpp_common \
    -lcurl -lpthread -lssl -lcrypto

./upload_example my-bucket myfile.txt my_uploaded_file.txt

#include <google/cloud/storage/client.h>
#include <iostream>
#include <fstream>
#include <vector>
#include <thread>
#include <mutex>

std::mutex upload_mutex;

void UploadChunk(google::cloud::storage::Client& client, 
                 const std::string& bucket_name, 
                 const std::string& object_name, 
                 std::ifstream& file, 
                 size_t start_pos, size_t chunk_size) {
    // 청크의 내용을 읽어들여 업로드
    file.seekg(start_pos);
    std::vector<char> buffer(chunk_size);
    file.read(buffer.data(), chunk_size);

    // 업로드 요청 실행
    auto writer = client.WriteObject(bucket_name, object_name);
    writer.write(buffer.data(), buffer.size());
    writer.Close();

    if (!writer.metadata()) {
        std::lock_guard<std::mutex> guard(upload_mutex);
        std::cerr << "청크 업로드 실패: " << writer.metadata().status() << std::endl;
    } else {
        std::lock_guard<std::mutex> guard(upload_mutex);
        std::cout << "청크 업로드 성공: " << start_pos << std::endl;
    }
}

void UploadFileParallel(const std::string& bucket_name, 
                        const std::string& file_path, 
                        const std::string& object_name, 
                        size_t chunk_size) {
    namespace gcs = google::cloud::storage;

    // Google Cloud Storage 클라이언트 생성
    auto client = gcs::Client::CreateDefaultClient().value();

    // 파일을 바이너리 모드로 열기
    std::ifstream file(file_path, std::ios::binary);
    if (!file) {
        std::cerr << "파일을 열 수 없습니다: " << file_path << std::endl;
        return;
    }

    // 파일 크기 얻기
    file.seekg(0, std::ios::end);
    size_t file_size = file.tellg();
    file.seekg(0, std::ios::beg);

    // 업로드할 청크 수 계산
    size_t num_chunks = (file_size + chunk_size - 1) / chunk_size;
    std::vector<std::thread> threads;

    // 병렬로 각 청크를 업로드
    for (size_t i = 0; i < num_chunks; ++i) {
        size_t start_pos = i * chunk_size;
        size_t current_chunk_size = std::min(chunk_size, file_size - start_pos);

        threads.push_back(std::thread(UploadChunk, std::ref(client), bucket_name, object_name, std::ref(file), start_pos, current_chunk_size));
    }

    // 모든 스레드가 완료될 때까지 기다림
    for (auto& t : threads) {
        t.join();
    }
}

int main(int argc, char* argv[]) {
    if (argc != 5) {
        std::cerr << "사용법: " << argv[0] << " <버킷 이름> <파일 경로> <객체 이름> <청크 크기(바이트)>" << std::endl;
        return 1;
    }

    std::string bucket_name = argv[1];
    std::string file_path = argv[2];
    std::string object_name = argv[3];
    size_t chunk_size = std::stoull(argv[4]);

    UploadFileParallel(bucket_name, file_path, object_name, chunk_size);
    return 0;
}

g++ -std=c++17 parallel_upload.cpp -o parallel_upload \
    -lgoogle_cloud_cpp_storage -lgoogle_cloud_cpp_common \
    -lcurl -lpthread -lssl -lcrypto

./parallel_upload my-bucket my_large_file.txt my_uploaded_file.txt 5242880

#include <google/cloud/storage/client.h>
#include <iostream>
#include <fstream>
#include <thread>
#include <chrono>

// 업로드 함수
void UploadFileWithRetry(const std::string& bucket_name, 
                         const std::string& file_path, 
                         const std::string& object_name, 
                         int max_retries = 5) {
    namespace gcs = google::cloud::storage;

    auto client = gcs::Client::CreateDefaultClient().value();
    std::ifstream file(file_path, std::ios::binary);
    if (!file) {
        std::cerr << "파일을 열 수 없습니다: " << file_path << std::endl;
        return;
    }

    int attempt = 0;
    while (attempt < max_retries) {
        auto writer = client.WriteObject(bucket_name, object_name);
        writer << file.rdbuf();  
        writer.Close();

        if (writer.metadata()) {
            std::cout << "파일 업로드 성공: " << writer.metadata()->name() << std::endl;
            return;
        } else {
            std::cerr << "업로드 실패: " << writer.metadata().status() 
                      << ", 재시도 중 (" << attempt + 1 << "/" << max_retries << ")" << std::endl;
            std::this_thread::sleep_for(std::chrono::seconds(2 * (attempt + 1))); // 지수 백오프
        }
        attempt++;
    }

    std::cerr << "최대 재시도 횟수 초과. 업로드 실패." << std::endl;
}

void LogError(const std::string& message) {
    std::ofstream log_file("upload_error.log", std::ios::app);
    if (log_file) {
        log_file << message << std::endl;
    }
}

void UploadFileWithLogging(const std::string& bucket_name, 
                           const std::string& file_path, 
                           const std::string& object_name) {
    try {
        UploadFileWithRetry(bucket_name, file_path, object_name);
    } catch (const std::exception& e) {
        std::string error_message = "업로드 중 예외 발생: " + std::string(e.what());
        std::cerr << error_message << std::endl;
        LogError(error_message);
    }
}

g++ -std=c++17 upload_with_retry.cpp -o upload_with_retry \
    -lgoogle_cloud_cpp_storage -lgoogle_cloud_cpp_common \
    -lcurl -lpthread -lssl -lcrypto

./upload_with_retry my-bucket largefile.txt uploaded_largefile.txt

#include <openssl/sha.h>
#include <google/cloud/storage/client.h>
#include <iostream>
#include <fstream>
#include <iomanip>

// 파일의 SHA-256 해시 계산
std::string CalculateFileHash(const std::string& file_path) {
    std::ifstream file(file_path, std::ios::binary);
    if (!file) {
        std::cerr << "파일을 열 수 없습니다: " << file_path << std::endl;
        return "";
    }

    SHA256_CTX sha256_ctx;
    SHA256_Init(&sha256_ctx);

    char buffer[8192];
    while (file.read(buffer, sizeof(buffer))) {
        SHA256_Update(&sha256_ctx, buffer, file.gcount());
    }
    SHA256_Update(&sha256_ctx, buffer, file.gcount()); // 마지막 남은 데이터 처리

    unsigned char hash[SHA256_DIGEST_LENGTH];
    SHA256_Final(hash, &sha256_ctx);

    std::ostringstream hex_stream;
    for (int i = 0; i < SHA256_DIGEST_LENGTH; i++) {
        hex_stream << std::hex << std::setw(2) << std::setfill('0') << (int)hash[i];
    }
    return hex_stream.str();
}

// GCS에서 객체의 MD5 해시값을 확인
std::string GetGCSObjectMD5(const google::cloud::storage::Client& client,
                             const std::string& bucket_name,
                             const std::string& object_name) {
    auto metadata = client.GetObjectMetadata(bucket_name, object_name);
    if (!metadata) {
        std::cerr << "GCS 객체 메타데이터 조회 실패: " << metadata.status() << std::endl;
        return "";
    }
    return metadata->md5_hash().value_or("");
}

// 파일 해시 비교 및 결과 출력
void VerifyFileUpload(const std::string& bucket_name,
                       const std::string& file_path,
                       const std::string& object_name) {
    namespace gcs = google::cloud::storage;

    // GCS 클라이언트 생성
    auto client = gcs::Client::CreateDefaultClient().value();

    // 로컬 파일의 SHA-256 해시 계산
    std::string local_hash = CalculateFileHash(file_path);

    if (local_hash.empty()) {
        std::cerr << "로컬 파일의 해시 계산 실패." << std::endl;
        return;
    }

    // GCS 객체의 MD5 해시 조회
    std::string gcs_md5 = GetGCSObjectMD5(client, bucket_name, object_name);

    if (gcs_md5.empty()) {
        std::cerr << "GCS 객체의 MD5 해시 조회 실패." << std::endl;
        return;
    }

    std::cout << "로컬 파일 SHA-256 해시: " << local_hash << std::endl;
    std::cout << "GCS 객체 MD5 해시: " << gcs_md5 << std::endl;

    if (local_hash == gcs_md5) {
        std::cout << "파일 업로드 검증 성공: 파일이 일치합니다." << std::endl;
    } else {
        std::cerr << "파일 업로드 검증 실패: 파일이 일치하지 않습니다." << std::endl;
    }
}

int main(int argc, char* argv[]) {
    if (argc != 4) {
        std::cerr << "사용법: " << argv[0] << " <버킷 이름> <파일 경로> <객체 이름>" << std::endl;
        return 1;
    }

    std::string bucket_name = argv[1];
    std::string file_path = argv[2];
    std::string object_name = argv[3];

    VerifyFileUpload(bucket_name, file_path, object_name);
    return 0;
}