C++에서 gRPC와 Protobuf를 이용한 마이크로서비스 구현

syntax = "proto3";  // 프로토콜 버전 지정

message User {
  int32 id = 1;         // 정수형 ID
  string name = 2;      // 문자열 이름
  repeated string emails = 3;  // 리스트 (여러 개의 이메일 저장 가능)
}

protoc --cpp_out=. user.proto

#include "user.pb.h"
#include <iostream>
#include <fstream>

int main() {
    // User 객체 생성 및 데이터 설정
    User user;
    user.set_id(1001);
    user.set_name("Alice");
    user.add_emails("alice@example.com");
    user.add_emails("alice.work@example.com");

    // 직렬화하여 파일 저장
    std::ofstream output("user_data.bin", std::ios::binary);
    user.SerializeToOstream(&output);
    output.close();

    // 역직렬화하여 파일에서 불러오기
    User new_user;
    std::ifstream input("user_data.bin", std::ios::binary);
    new_user.ParseFromIstream(&input);
    input.close();

    // 역직렬화된 데이터 출력
    std::cout << "User ID: " << new_user.id() << std::endl;
    std::cout << "Name: " << new_user.name() << std::endl;
    for (const auto& email : new_user.emails()) {
        std::cout << "Email: " << email << std::endl;
    }

    return 0;
}

User ID: 1001
Name: Alice
Email: alice@example.com
Email: alice.work@example.com

syntax = "proto3";

service UserService {
  rpc GetUser(UserRequest) returns (UserResponse);
}

message UserRequest {
  int32 id = 1;
}

message UserResponse {
  int32 id = 1;
  string name = 2;
  string email = 3;
}

protoc --cpp_out=. --grpc_out=. --plugin=protoc-gen-grpc=`which grpc_cpp_plugin` user.proto

#include <iostream>
#include <memory>
#include <string>
#include <grpcpp/grpcpp.h>
#include "user.grpc.pb.h"

using grpc::Server;
using grpc::ServerBuilder;
using grpc::ServerContext;
using grpc::Status;

// UserService 구현
class UserServiceImpl final : public UserService::Service {
public:
    Status GetUser(ServerContext* context, const UserRequest* request, UserResponse* response) override {
        // 요청된 사용자 ID 출력
        std::cout << "Received request for User ID: " << request->id() << std::endl;

        // 더미 데이터 설정
        response->set_id(request->id());
        response->set_name("Alice");
        response->set_email("alice@example.com");

        return Status::OK;
    }
};

// gRPC 서버 실행 함수
void RunServer() {
    std::string server_address("0.0.0.0:50051");
    UserServiceImpl service;

    ServerBuilder builder;
    builder.AddListeningPort(server_address, grpc::InsecureServerCredentials());
    builder.RegisterService(&service);

    std::unique_ptr<Server> server(builder.BuildAndStart());
    std::cout << "Server listening on " << server_address << std::endl;
    server->Wait();
}

int main() {
    RunServer();
    return 0;
}

g++ user.pb.cc user.grpc.pb.cc server.cpp -o server -lgrpc++ -lprotobuf -lpthread
./server

Server listening on 0.0.0.0:50051
Received request for User ID: 1

#include <iostream>
#include <memory>
#include <string>
#include <grpcpp/grpcpp.h>
#include "user.grpc.pb.h"

using grpc::Channel;
using grpc::ClientContext;
using grpc::Status;

// UserService 클라이언트 클래스 정의
class UserServiceClient {
public:
    UserServiceClient(std::shared_ptr<Channel> channel)
        : stub_(UserService::NewStub(channel)) {}

    // 서버의 GetUser 메서드를 호출하는 함수
    void GetUser(int user_id) {
        UserRequest request;
        request.set_id(user_id);

        UserResponse response;
        ClientContext context;

        Status status = stub_->GetUser(&context, request, &response);

        if (status.ok()) {
            std::cout << "User ID: " << response.id() << std::endl;
            std::cout << "Name: " << response.name() << std::endl;
            std::cout << "Email: " << response.email() << std::endl;
        } else {
            std::cout << "RPC failed: " << status.error_message() << std::endl;
        }
    }

private:
    std::unique_ptr<UserService::Stub> stub_;
};

// 클라이언트 실행 함수
int main() {
    // gRPC 채널 생성 (localhost:50051)
    UserServiceClient client(grpc::CreateChannel("localhost:50051", grpc::InsecureChannelCredentials()));

    std::cout << "Requesting User with ID 1..." << std::endl;
    client.GetUser(1);

    return 0;
}

g++ user.pb.cc user.grpc.pb.cc client.cpp -o client -lgrpc++ -lprotobuf -lpthread
./client

Requesting User with ID 1...
User ID: 1
Name: Alice
Email: alice@example.com

# 필수 패키지 설치
sudo apt update
sudo apt install -y build-essential autoconf libtool pkg-config

# Protobuf 및 gRPC 설치
git clone --recurse-submodules -b v1.51.0 https://github.com/grpc/grpc
cd grpc
mkdir -p cmake/build
cd cmake/build
cmake -DgRPC_BUILD_TESTS=OFF -DCMAKE_INSTALL_PREFIX=/usr/local ../..
make -j$(nproc)
sudo make install

git clone https://github.com/microsoft/vcpkg.git
cd vcpkg
bootstrap-vcpkg.bat
vcpkg install grpc protobuf

protoc --cpp_out=. --grpc_out=. --plugin=protoc-gen-grpc=`which grpc_cpp_plugin` user.proto

cmake_minimum_required(VERSION 3.14)
project(grpc_example)

find_package(Protobuf REQUIRED)
find_package(gRPC REQUIRED)

set(PROTO_FILES user.proto)

# Protobuf 및 gRPC 코드 생성
protobuf_generate_cpp(PROTO_SRCS PROTO_HDRS ${PROTO_FILES})
grpc_generate_cpp(GRPC_SRCS GRPC_HDRS ${PROTO_FILES})

add_executable(server server.cpp ${PROTO_SRCS} ${GRPC_SRCS})
add_executable(client client.cpp ${PROTO_SRCS} ${GRPC_SRCS})

target_link_libraries(server gRPC::grpc++ protobuf::libprotobuf)
target_link_libraries(client gRPC::grpc++ protobuf::libprotobuf)

mkdir build && cd build
cmake ..
make -j$(nproc)

# 서버 실행
./server

Server listening on 0.0.0.0:50051

# 클라이언트 실행
./client

Requesting User with ID 1...
User ID: 1
Name: Alice
Email: alice@example.com

#include <grpcpp/server_context.h>
#include <grpcpp/support/server_interceptor.h>
#include <iostream>
#include <chrono>

// gRPC 서버 인터셉터 클래스 정의
class LoggingInterceptor : public grpc::experimental::ServerInterceptor {
public:
    void Intercept(grpc::experimental::ServerRpcInfo* rpc_info,
                   grpc::experimental::InterceptorBatchMethods* methods) override {
        auto start = std::chrono::high_resolution_clock::now();

        // 요청된 메서드 이름 출력
        std::cout << "[gRPC Server] 요청된 메서드: " 
                  << rpc_info->method() << std::endl;

        methods->Proceed();  // 원래의 gRPC 요청을 계속 진행

        auto end = std::chrono::high_resolution_clock::now();
        std::cout << "[gRPC Server] 요청 처리 완료 ("
                  << std::chrono::duration_cast<std::chrono::milliseconds>(end - start).count()
                  << " ms)" << std::endl;
    }
};

#include <grpcpp/grpcpp.h>
#include "user.grpc.pb.h"

class UserServiceImpl final : public UserService::Service {
public:
    Status GetUser(ServerContext* context, const UserRequest* request, UserResponse* response) override {
        response->set_id(request->id());
        response->set_name("Alice");
        response->set_email("alice@example.com");
        return Status::OK;
    }
};

void RunServer() {
    std::string server_address("0.0.0.0:50051");
    UserServiceImpl service;

    grpc::ServerBuilder builder;
    builder.AddListeningPort(server_address, grpc::InsecureServerCredentials());
    builder.RegisterService(&service);

    // 인터셉터 적용
    std::vector<std::unique_ptr<grpc::experimental::ServerInterceptorFactoryInterface>> interceptors;
    interceptors.push_back(std::make_unique<grpc::experimental::GenericInterceptorFactory<LoggingInterceptor>>());
    builder.experimental().SetInterceptorCreators(std::move(interceptors));

    std::unique_ptr<grpc::Server> server(builder.BuildAndStart());
    std::cout << "Server listening on " << server_address << std::endl;
    server->Wait();
}

int main() {
    RunServer();
    return 0;
}

Server listening on 0.0.0.0:50051
[gRPC Server] 요청된 메서드: /UserService/GetUser
[gRPC Server] 요청 처리 완료 (2 ms)

#include <grpcpp/grpcpp.h>
#include <grpcpp/client_context.h>
#include <grpcpp/support/client_interceptor.h>
#include <iostream>

// API 키를 요청 헤더에 추가하는 인터셉터
class AuthInterceptor : public grpc::experimental::ClientInterceptor {
public:
    explicit AuthInterceptor(const std::string& api_key) : api_key_(api_key) {}

    void Intercept(grpc::experimental::ClientRpcInfo* rpc_info,
                   grpc::experimental::InterceptorBatchMethods* methods) override {
        if (methods->QueryInterceptionHookPoint() ==
            grpc::experimental::InterceptionHookPoints::PRE_SEND_INITIAL_METADATA) {
            methods->GetSendInitialMetadata()->insert({"authorization", api_key_});
        }
        methods->Proceed();
    }

private:
    std::string api_key_;
};

// 클라이언트 인터셉터 팩토리
class AuthInterceptorFactory : public grpc::experimental::ClientInterceptorFactoryInterface {
public:
    explicit AuthInterceptorFactory(const std::string& api_key) : api_key_(api_key) {}

    std::unique_ptr<grpc::experimental::ClientInterceptor> CreateClientInterceptor(
        grpc::experimental::ClientRpcInfo* info) override {
        return std::make_unique<AuthInterceptor>(api_key_);
    }

private:
    std::string api_key_;
};

// 클라이언트 코드
class UserServiceClient {
public:
    UserServiceClient(std::shared_ptr<grpc::Channel> channel)
        : stub_(UserService::NewStub(channel)) {}

    void GetUser(int user_id) {
        UserRequest request;
        request.set_id(user_id);

        UserResponse response;
        ClientContext context;

        Status status = stub_->GetUser(&context, request, &response);
        if (status.ok()) {
            std::cout << "User ID: " << response.id() << std::endl;
            std::cout << "Name: " << response.name() << std::endl;
            std::cout << "Email: " << response.email() << std::endl;
        } else {
            std::cout << "RPC failed: " << status.error_message() << std::endl;
        }
    }

private:
    std::unique_ptr<UserService::Stub> stub_;
};

// 클라이언트 실행
int main() {
    std::string api_key = "Bearer my-secret-token";
    std::shared_ptr<grpc::Channel> channel = grpc::CreateChannel("localhost:50051", grpc::InsecureChannelCredentials());

    // 인증 인터셉터 추가
    std::vector<std::unique_ptr<grpc::experimental::ClientInterceptorFactoryInterface>> interceptors;
    interceptors.push_back(std::make_unique<AuthInterceptorFactory>(api_key));
    auto channel_with_interceptors = grpc::experimental::CreateChannelWithInterceptors(channel, std::move(interceptors));

    UserServiceClient client(channel_with_interceptors);
    client.GetUser(1);

    return 0;
}

[gRPC Client] API Key 추가됨: Bearer my-secret-token
User ID: 1
Name: Alice
Email: alice@example.com

grpc::ChannelArguments channel_args;
channel_args.SetInt(GRPC_ARG_KEEPALIVE_TIME_MS, 10000);   // 10초마다 KeepAlive 신호 전송
channel_args.SetInt(GRPC_ARG_KEEPALIVE_TIMEOUT_MS, 5000); // 응답 대기 시간
channel_args.SetInt(GRPC_ARG_KEEPALIVE_PERMIT_WITHOUT_CALLS, 1);

auto channel = grpc::CreateCustomChannel("localhost:50051",
                                         grpc::InsecureChannelCredentials(),
                                         channel_args);

grpc::ClientContext context;
context.set_compression_algorithm(GRPC_COMPRESS_GZIP);

class AsyncServer {
public:
    void Run() {
        ServerBuilder builder;
        builder.AddListeningPort("0.0.0.0:50051", grpc::InsecureServerCredentials());
        builder.RegisterService(&service_);

        cq_ = builder.AddCompletionQueue();
        server_ = builder.BuildAndStart();

        HandleRpcs();
    }

private:
    void HandleRpcs() {
        new CallData(&service_, cq_.get());
        void* tag;
        bool ok;
        while (cq_->Next(&tag, &ok)) {
            static_cast<CallData*>(tag)->Proceed();
        }
    }

    std::unique_ptr<grpc::ServerCompletionQueue> cq_;
    std::unique_ptr<grpc::Server> server_;
    UserService::AsyncService service_;
};

Status StreamData(ServerContext* context,
                  const StreamRequest* request,
                  ServerWriter<StreamResponse>* writer) override {
    for (int i = 0; i < 10; i++) {
        StreamResponse response;
        response.set_message("Chunk " + std::to_string(i));
        writer->Write(response);
    }
    return Status::OK;
}

grpc::ChannelArguments channel_args;
channel_args.SetInt(GRPC_ARG_TCP_NODELAY, 1);