C++에서 Boost.Beast와 함께 JSON RPC로 API 서버 만들기

도입 문구

C++는 고성능 네트워크 서버를 구축할 수 있는 강력한 언어입니다. 특히 Boost.Beast 라이브러리는 HTTP, WebSocket, 그리고 JSON RPC와 같은 프로토콜을 효율적으로 처리할 수 있게 해줍니다. 본 기사에서는 Boost.Beast와 JSON RPC를 활용하여 간단한 API 서버를 구축하는 방법을 단계별로 설명합니다.

JSON RPC란 무엇인가

JSON RPC는 원격 프로시저 호출(Remote Procedure Call, RPC)을 위한 경량의 프로토콜입니다. 클라이언트는 서버에 JSON 형식으로 요청을 보내고, 서버는 해당 요청을 처리한 후 JSON 형식으로 응답합니다.

JSON RPC의 특징

언어 독립성: 다양한 언어에서 구현이 가능
단순성: HTTP를 통해 쉽게 구현 가능
비동기 처리: 높은 성능을 요구하는 애플리케이션에서 유용

Boost.Beast 소개

Boost.Beast는 C++에서 HTTP와 WebSocket을 처리하는 라이브러리로, HTTP 서버와 클라이언트 기능을 제공하며, JSON RPC와 함께 사용할 수 있습니다. Boost.Beast는 ASIO 기반으로 비동기 I/O를 처리하여 높은 성능을 보장합니다.

Boost.Beast의 장점

고성능: 비동기 처리와 멀티스레딩을 통한 고속 처리
확장성: 복잡한 HTTP 요청을 쉽게 처리 가능
호환성: Boost 라이브러리와의 완벽한 호환

C++ 프로젝트 설정하기

Boost.Beast를 사용하기 위해서는 먼저 C++ 프로젝트에 Boost 라이브러리를 설정해야 합니다. CMake를 이용해 Boost를 포함시키는 방법을 알아봅니다.

CMake 설정 예시

CMake를 사용하여 Boost를 포함시키는 방법은 매우 간단합니다. 다음은 CMake 설정 예시입니다.

find_package(Boost 1.70 REQUIRED)
target_link_libraries(MyProject Boost::Boost)

Boost 설치 방법

Boost 라이브러리를 시스템에 설치한 후, CMake가 이를 찾을 수 있도록 경로를 지정해야 합니다. Boost를 설치하는 방법은 시스템에 따라 다릅니다. 예를 들어, Linux에서는 apt-get이나 yum 패키지 관리자를 사용하여 설치할 수 있습니다.

sudo apt-get install libboost-all-dev

이 설정을 통해 프로젝트에서 Boost.Beast를 비롯한 Boost 라이브러리를 사용할 수 있습니다.

JSON RPC 요청 처리하기

Boost.Beast를 사용하여 JSON RPC 요청을 처리하는 방법을 설명합니다. 기본적으로 JSON RPC 요청은 HTTP POST 방식으로 이루어집니다. 요청을 파싱하고, 서버에서 해당 요청을 처리하여 응답을 반환하는 방법을 다룹니다.

JSON RPC 요청 예시

JSON RPC 요청은 일반적으로 아래와 같은 형식으로 전송됩니다. 클라이언트는 method, params, id를 포함한 JSON 객체를 서버로 전송하고, 서버는 이를 처리한 후 응답을 반환합니다.

{
  "jsonrpc": "2.0",
  "method": "getData",
  "params": [],
  "id": 1
}

요청 처리 흐름

HTTP 요청 수신: Boost.Beast 서버는 HTTP POST 요청을 수신합니다.
JSON 파싱: 요청의 본문에서 JSON 데이터를 추출하여 파싱합니다.
메서드 호출: 파싱된 요청에서 method를 확인하고, 해당 메서드에 맞는 로직을 실행합니다.
응답 생성: 메서드 실행 결과를 기반으로 JSON 응답을 생성하여 클라이언트에게 반환합니다.

예시 코드

다음은 Boost.Beast를 사용하여 JSON RPC 요청을 처리하는 간단한 코드 예시입니다.

#include <boost/beast.hpp>
#include <boost/asio.hpp>
#include <nlohmann/json.hpp>

using json = nlohmann::json;

void handle_request(boost::beast::http::request<boost::beast::http::string_body>& req) {
    try {
        // JSON 파싱
        json request_json = json::parse(req.body());

        // 메서드 처리
        if (request_json["method"] == "getData") {
            // 데이터 처리 로직
            json response_json = {
                {"jsonrpc", "2.0"},
                {"result", "success"},
                {"id", request_json["id"]}
            };

            // 응답 전송
            // (이후 응답을 HTTP로 포장하여 클라이언트에 전송하는 코드 추가)
        }
    } catch (const std::exception& e) {
        // 예외 처리
    }
}

위 예시는 getData 메서드에 대한 요청을 처리하는 간단한 로직을 보여줍니다. 요청을 파싱하고, 해당 메서드를 호출한 뒤 결과를 JSON 형식으로 반환합니다.

Boost.Beast로 HTTP 서버 구현

Boost.Beast를 사용하여 간단한 HTTP 서버를 구현하는 방법을 설명합니다. 이 서버는 클라이언트의 요청을 받아 JSON RPC 형식으로 응답합니다. 아래에서는 서버를 구성하고 요청을 처리하는 기본적인 방법을 다룹니다.

HTTP 서버 기본 구조

Boost.Beast는 비동기 서버를 쉽게 구현할 수 있도록 설계되어 있습니다. HTTP 서버는 boost::beast::http::request를 사용하여 요청을 받고, boost::beast::http::response로 응답을 반환합니다.

기본 HTTP 서버 코드 예시

다음은 Boost.Beast를 사용하여 간단한 HTTP 서버를 구현하는 코드 예시입니다.

#include <boost/beast.hpp>
#include <boost/asio.hpp>
#include <iostream>

namespace beast = boost::beast;
namespace asio = boost::asio;

using tcp = asio::ip::tcp;
using namespace std;

void handle_request(beast::http::request<beast::http::string_body>& req, beast::http::response<beast::http::string_body>& res) {
    res.version(req.version());
    res.keep_alive(req.keep_alive());
    res.result(beast::http::status::ok);
    res.set(beast::http::field::content_type, "application/json");
    res.body() = R"({"jsonrpc":"2.0","result":"success","id":1})";  // 예시 응답
}

void session(tcp::socket& socket) {
    beast::flat_buffer buffer;

    // HTTP 요청 수신
    beast::http::request<beast::http::string_body> req;
    beast::http::read(socket, buffer, req);

    // 응답 생성
    beast::http::response<beast::http::string_body> res;
    handle_request(req, res);

    // HTTP 응답 전송
    beast::http::write(socket, res);
}

void server(asio::io_context& io_context, short port) {
    tcp::acceptor acceptor(io_context, tcp::endpoint(tcp::v4(), port));

    while (true) {
        tcp::socket socket(io_context);
        acceptor.accept(socket);
        session(socket);  // 클라이언트 요청 처리
    }
}

int main() {
    try {
        asio::io_context io_context;
        short port = 8080;  // 서버 포트
        server(io_context, port);  // 서버 시작
    } catch (const std::exception& e) {
        cerr << "Error: " << e.what() << endl;
    }

    return 0;
}

설명

session() 함수는 클라이언트로부터 HTTP 요청을 받고, 그에 대한 응답을 생성하여 전송하는 역할을 합니다.
handle_request() 함수에서는 JSON RPC 형식의 응답을 생성합니다. 여기서는 간단한 예시 응답을 사용했습니다.
server() 함수는 소켓을 통해 클라이언트를 수신하고, session()을 호출하여 요청을 처리합니다.

이 코드를 통해 Boost.Beast로 HTTP 서버를 구현하고, 클라이언트의 요청에 JSON 형식으로 응답을 반환하는 간단한 예제를 만들 수 있습니다.

JSON 파싱 및 응답 보내기

JSON RPC 요청을 처리한 후, JSON 형식으로 응답을 보내는 방법을 설명합니다. Boost.Beast와 JSON 라이브러리인 nlohmann/json을 함께 사용하여 JSON을 파싱하고 응답을 생성합니다.

JSON 응답 예시

JSON RPC 응답은 클라이언트에게 반환할 데이터를 JSON 형식으로 구조화하여 전달합니다. 응답에는 jsonrpc, result, 그리고 id가 포함됩니다. 이 예시에서는 요청을 처리한 결과를 포함한 응답을 반환합니다.

{
  "jsonrpc": "2.0",
  "result": "success",
  "id": 1
}

JSON 응답 생성하기

Boost.Beast와 nlohmann/json 라이브러리를 사용하여 JSON 응답을 생성하는 방법은 다음과 같습니다. 이 라이브러리는 JSON 객체를 쉽게 다룰 수 있도록 도와줍니다.

응답 생성 코드 예시

#include <boost/beast.hpp>
#include <boost/asio.hpp>
#include <nlohmann/json.hpp>
#include <iostream>

using json = nlohmann::json;

void send_json_response(boost::beast::http::response<boost::beast::http::string_body>& res) {
    // JSON 응답 생성
    json response_json = {
        {"jsonrpc", "2.0"},
        {"result", "success"},
        {"id", 1}
    };

    // 응답 본문에 JSON 데이터 삽입
    res.body() = response_json.dump();  // JSON 객체를 문자열로 변환하여 응답 본문에 삽입

    // 응답 헤더 설정
    res.set(boost::beast::http::field::content_type, "application/json");
    res.result(boost::beast::http::status::ok);
}

void handle_request(boost::beast::http::request<boost::beast::http::string_body>& req) {
    // 응답 객체 생성
    boost::beast::http::response<boost::beast::http::string_body> res;

    // JSON 응답 생성
    send_json_response(res);

    // 응답 전송 (HTTP 소켓을 통해)
    // (socket 전송 코드 포함)
}

설명

send_json_response() 함수는 nlohmann::json을 사용하여 JSON 응답을 생성합니다. response_json.dump()는 JSON 객체를 문자열로 변환하여 HTTP 응답의 본문에 넣습니다.
응답의 content-type 헤더는 application/json으로 설정되어 JSON 데이터임을 명시합니다.
handle_request() 함수는 요청을 받은 후 이 응답을 생성하고, HTTP 소켓을 통해 전송할 준비를 합니다.

이 방법을 통해 JSON RPC 서버는 클라이언트가 보낸 요청을 처리하고, JSON 형식의 응답을 반환할 수 있습니다.

비동기 I/O로 성능 최적화

Boost.Beast는 비동기 I/O를 활용하여 높은 성능을 제공합니다. 네트워크 서버가 많은 요청을 처리할 때, 비동기 처리 방식을 사용하면 서버가 블로킹 없이 동시에 여러 클라이언트를 처리할 수 있습니다. 이 섹션에서는 비동기 I/O를 설정하고 성능을 최적화하는 방법을 설명합니다.

비동기 I/O의 중요성

비동기 I/O는 서버가 요청을 처리하는 동안 다른 작업을 계속해서 처리할 수 있게 해줍니다. 이는 서버의 응답 시간을 단축시키고, 높은 동시 처리 성능을 제공합니다. 특히 네트워크 서버에서는 여러 클라이언트가 동시에 연결될 수 있기 때문에 비동기 처리가 매우 중요합니다.

비동기 I/O 사용 예시

Boost.Beast는 boost::asio::io_context를 사용하여 비동기 작업을 처리합니다. 서버는 요청을 비동기적으로 읽고, 응답을 비동기적으로 작성한 뒤 클라이언트에게 전송합니다.

#include <boost/asio.hpp>
#include <boost/beast.hpp>
#include <iostream>

namespace asio = boost::asio;
namespace beast = boost::beast;

using tcp = asio::ip::tcp;

class async_server {
public:
    async_server(asio::io_context& io_context, short port)
        : acceptor_(io_context, tcp::endpoint(tcp::v4(), port)) {
        accept_connections();
    }

    void accept_connections() {
        auto socket = std::make_shared<tcp::socket>(acceptor_.get_io_context());
        acceptor_.async_accept(*socket, [this, socket](boost::system::error_code ec) {
            if (!ec) {
                handle_request(socket);
            }
            accept_connections();
        });
    }

    void handle_request(std::shared_ptr<tcp::socket> socket) {
        boost::beast::flat_buffer buffer;

        boost::beast::http::request<boost::beast::http::string_body> req;
        boost::beast::http::read(*socket, buffer, req);

        boost::beast::http::response<boost::beast::http::string_body> res;
        res.result(boost::beast::http::status::ok);
        res.set(boost::beast::http::field::content_type, "application/json");
        res.body() = R"({"jsonrpc":"2.0","result":"success","id":1})";

        boost::beast::http::write(*socket, res);
    }

private:
    tcp::acceptor acceptor_;
};

int main() {
    try {
        asio::io_context io_context;
        async_server server(io_context, 8080);
        io_context.run();
    } catch (const std::exception& e) {
        std::cerr << "Error: " << e.what() << std::endl;
    }
}

설명

accept_connections() 함수는 비동기적으로 클라이언트의 연결을 수락합니다. 클라이언트가 연결되면 handle_request()를 호출하여 요청을 처리하고 응답을 반환합니다.
async_accept()는 클라이언트의 연결을 비동기적으로 수락하며, 이를 통해 서버는 여러 클라이언트를 동시에 처리할 수 있습니다.
비동기 처리를 통해 서버는 블로킹 없이 요청을 처리하므로, 동시에 여러 클라이언트와의 연결을 효율적으로 관리할 수 있습니다.

비동기 I/O를 활용하면 높은 동시성 처리 성능을 얻을 수 있습니다. 서버는 각 요청에 대해 기다리지 않고 즉시 다른 요청을 처리할 수 있어, 성능이 크게 향상됩니다.

에러 처리 및 예외 관리

Boost.Beast를 사용하여 API 서버를 구축할 때, 적절한 에러 처리와 예외 관리는 중요한 부분입니다. 요청을 처리하는 중에 발생할 수 있는 다양한 오류를 처리하고, 클라이언트에게 유의미한 오류 메시지를 반환하는 방법을 설명합니다.

에러 처리 기본 개념

HTTP 서버에서 발생할 수 있는 오류는 여러 가지가 있을 수 있습니다. 예를 들어, 클라이언트가 잘못된 요청을 보냈거나 서버 내부에서 예기치 못한 오류가 발생할 수 있습니다. 이러한 오류를 처리하고, 클라이언트에게 적절한 HTTP 상태 코드와 메시지를 반환하는 것이 중요합니다.

일반적인 HTTP 상태 코드

200 OK: 요청이 성공적으로 처리됨
400 Bad Request: 클라이언트의 요청이 잘못됨
404 Not Found: 요청한 리소스를 찾을 수 없음
500 Internal Server Error: 서버 내부에서 오류 발생

예외 처리 예시

Boost.Beast와 Boost.Asio를 사용할 때, 예외 처리를 잘 관리하는 것이 중요합니다. 예를 들어, 클라이언트의 요청을 잘못 파싱하거나 서버 내부에서 예기치 못한 오류가 발생하면 이를 적절히 처리해야 합니다.

예시 코드

다음은 Boost.Beast를 사용한 HTTP 서버에서 예외를 처리하는 방법을 보여줍니다.

#include <boost/beast.hpp>
#include <boost/asio.hpp>
#include <iostream>
#include <nlohmann/json.hpp>

namespace beast = boost::beast;
namespace asio = boost::asio;

using json = nlohmann::json;
using tcp = asio::ip::tcp;

void handle_request(std::shared_ptr<tcp::socket> socket) {
    try {
        beast::flat_buffer buffer;
        beast::http::request<beast::http::string_body> req;
        beast::http::read(*socket, buffer, req);

        // 요청 파싱 중 오류가 발생하면 400 Bad Request 반환
        if (req.body().empty()) {
            throw std::runtime_error("Invalid request body");
        }

        // JSON RPC 응답 생성
        beast::http::response<beast::http::string_body> res;
        res.result(beast::http::status::ok);
        res.set(beast::http::field::content_type, "application/json");
        res.body() = R"({"jsonrpc":"2.0","result":"success","id":1})";

        beast::http::write(*socket, res);
    } catch (const std::exception& e) {
        // 예외 발생 시 400 Bad Request와 오류 메시지 반환
        beast::http::response<beast::http::string_body> res;
        res.result(beast::http::status::bad_request);
        res.set(beast::http::field::content_type, "application/json");
        res.body() = json{{"error", e.what()}}.dump();  // 오류 메시지 반환

        beast::http::write(*socket, res);
    }
}

void accept_connection(asio::io_context& io_context, short port) {
    tcp::acceptor acceptor(io_context, tcp::endpoint(tcp::v4(), port));

    while (true) {
        auto socket = std::make_shared<tcp::socket>(io_context);
        acceptor.accept(*socket);
        handle_request(socket);  // 요청 처리
    }
}

int main() {
    try {
        asio::io_context io_context;
        short port = 8080;
        accept_connection(io_context, port);  // 서버 시작
    } catch (const std::exception& e) {
        std::cerr << "Server error: " << e.what() << std::endl;
    }

    return 0;
}

설명

handle_request() 함수에서는 요청을 처리하는 중에 예외가 발생할 경우, 클라이언트에게 400 Bad Request 상태 코드와 오류 메시지를 JSON 형식으로 반환합니다.
try-catch 블록을 사용하여 요청 처리 중 발생할 수 있는 다양한 예외를 잡아내고, 이를 클라이언트에게 알립니다.
오류 메시지는 JSON 형태로 응답 본문에 담아 반환하며, error 필드를 사용해 오류 내용을 전달합니다.

에러 로그 기록

서버에서 발생한 오류를 클라이언트에게만 반환하는 것 외에도, 서버 로그에 기록하여 디버깅 및 모니터링에 활용하는 것이 좋습니다. std::cerr 또는 로그 라이브러리를 사용하여 서버 내부의 에러 로그를 기록할 수 있습니다.

이와 같은 방식으로 Boost.Beast를 활용한 서버에서 발생할 수 있는 다양한 예외를 처리하고, 적절한 상태 코드와 응답 메시지를 클라이언트에게 반환할 수 있습니다.

요약

본 기사에서는 C++에서 Boost.Beast와 JSON RPC를 사용하여 API 서버를 구축하는 방법을 다뤘습니다. 클라이언트의 요청을 비동기적으로 처리하고, JSON RPC 형식으로 응답을 보내는 방법을 설명했습니다. 또한, 성능 최적화를 위한 비동기 I/O 처리와 오류 발생 시 적절한 예외 관리 방안을 제시했습니다.

Boost.Beast와 nlohmann/json을 활용하면 고성능 API 서버를 구축할 수 있으며, 비동기 처리로 여러 클라이언트의 요청을 효율적으로 처리할 수 있습니다. 에러 처리와 예외 관리도 중요한 부분으로, 클라이언트에게 유의미한 오류 메시지를 전달하는 방법을 소개했습니다.

Boost.Beast의 강력한 비동기 I/O 기능과 JSON RPC의 표준화된 요청/응답 방식으로, 빠르고 안정적인 API 서버를 구축할 수 있습니다.