ドキュメント価格ブログ
お問い合わせ
ログイン無料で新規登録
Back to Tech Articles

Rust 웹 서비스의 견고성 확보: Serde와 Validator를 이용한 타입 안전한 요청 본문 파싱 및 검증

9月 09, 2025
# Misc

Ethan Miller

Product Engineer · Leapcell

この記事はEnglish、日本語、Deutschでも利用できます
Cover of "Rust 웹 서비스의 견고성 확보: Serde와 Validator를 이용한 타입 안전한 요청 본문 파싱 및 검증"

소개

웹 서비스 개발의 세계에서 들어오는 요청 본문을 처리하는 것은 매우 중요한 작업입니다. 불완전하거나 잘못 처리된 데이터는 미묘한 버그, 예상치 못한 동작부터 주입 공격과 같은 심각한 보안 취약점까지 다양한 문제를 야기할 수 있습니다. 현대 웹 애플리케이션은 효율적인 데이터 처리뿐만 아니라 데이터 무결성과 애플리케이션 안정성을 보장하는 강력한 검증 메커니즘을 요구합니다. Rust는 강력한 타입 시스템과 메모리 안전성에 중점을 두어 매우 안정적인 웹 서비스를 구축할 수 있는 훌륭한 기반을 제공합니다. 하지만 Rust를 사용하는 것만으로는 충분하지 않습니다. 개발자는 데이터 처리를 위한 모범 사례를 채택해야 합니다. 이 글에서는 두 가지 강력한 Rust 크레이트인 serde와 validator를 어떻게 원활하게 통합하여 타입 안전한 요청 본문 파싱과 포괄적인 검증을 달성함으로써 웹 애플리케이션의 안정성과 보안을 향상시킬 수 있는지 살펴봅니다.

견고한 웹 서비스를 위한 데이터 파싱과 검증 분리

구현 세부 사항을 자세히 살펴보기 전에, 솔루션의 기반이 되는 핵심 개념을 간략하게 정의해 보겠습니다.

  • 요청 본문 파싱(Request Body Parsing): 일반적으로 JSON 또는 URL 인코딩 양식과 같은 형식의 원시 데이터를 들어오는 HTTP 요청에서 가져와 애플리케이션이 이해하고 작업할 수 있는 구조화된 데이터로 변환하는 프로세스입니다. Rust에서는 일반적으로 데이터를 Rust 구조체로 역직렬화하는 것을 의미합니다.
  • 타입 안전성(Type Safety): Rust와 같은 프로그래밍 언어의 특징으로, 타입 오류를 방지하는 것을 목표로 합니다. 요청 본문 파싱에 적용될 때, 이는 역직렬화된 데이터가 정의된 Rust 데이터 타입을 엄격하게 준수하도록 보장하여 런타임이 아닌 컴파일 타임에 불일치를 잡는다는 것을 의미합니다.
  • 데이터 검증(Data Validation): 파싱된 데이터가 특정 기준, 규칙 또는 제약 조건을 충족하는지 확인하는 프로세스입니다. 이는 기본 타입 검사를 넘어 비즈니스 로직, 데이터 형식 요구 사항(예: 이메일 패턴, 문자열 길이), 값 범위 등을 시행하는 것을 포함합니다.
  • serde: Rust 데이터 구조를 효율적이고 범용적으로 직렬화 및 역직렬화하기 위한 강력하고 인기 있는 Rust 라이브러리입니다. JSON, YAML, Bincode를 포함한 다양한 데이터 형식을 지원합니다. 웹 서비스의 경우, JSON 요청 본문을 처리하는 데 serde_json이 특히 관련이 있습니다.
  • validator: 구조체에 검증 규칙을 선언적으로 추가할 수 있는 Rust 크레이트입니다. #[validate(email)], #[validate(range(min = 0, max = 100))], #[validate(length(min = 1))]와 같이 광범위한 내장 검증기를 지원하며 사용자 정의 검증 로직도 허용합니다.

수동 파싱 및 검증의 문제점

전용 도구 없이 요청 본문을 파싱하고 검증하는 것은 종종 반복적이고 오류가 발생하기 쉬운 수동 검사 및 오류 처리를 수반하며, 이는 빠르게 if-else 문으로 구성된 스파게티 코드가 될 수 있습니다.

// 조악하고 오류가 발생하기 쉬운 접근 방식 (의사 코드)
fn create_user_manual(request_body: String) -> Result<User, String> {
    // 1. 수동으로 JSON 파싱
    let json_map: HashMap<String, Value> = parse_json_string(request_body)?;

    let username = json_map.get("username").and_then(|v| v.as_str());
    let email = json_map.get("email").and_then(|v| v.as_str());
    let age = json_map.get("age").and_then(|v| v.as_u64());

    // 2. 수동 검증
    if username.is_none() || username.unwrap().len() < 3 {
        return Err("Username too short".to_string());
    }
    if email.is_none() || !is_valid_email(email.unwrap()) {
        return Err("Invalid email format".to_string());
    }
    if age.is_none() || age.unwrap() < 18 {
        return Err("User must be adult".to_string());
    }

    Ok(User {
        username: username.unwrap().to_string(),
        email: email.unwrap().to_string(),
        age: age.unwrap() as u32,
    })
}

이 접근 방식은 장황하고 유지 관리가 어려우며 Rust로 알려진 컴파일 타임 안전성이 부족합니다.

타입 안전한 파싱을 위한 serde 솔루션

serde는 역직렬화 프로세스를 크게 단순화합니다. 예상되는 요청 본문의 구조를 반영하는 Rust 구조체를 정의하면 serde가 자동으로 변환을 처리합니다.

먼저 Cargo.toml에 serde와 serde_json을 추가합니다.

[dependencies]
serde = { version = "1.0", features = ["derive"] }
serde_json = "1.0"

이제 요청 데이터 구조를 정의합니다.

use serde::Deserialize;

#[derive(Debug, Deserialize)]
struct CreateUserRequest {
    username: String,
    email: String,
    age: u32,
}

fn process_request_with_serde(json_data: &str) -> Result<CreateUserRequest, serde_json::Error> {
    let request: CreateUserRequest = serde_json::from_str(json_data)?;
    Ok(request)
}

fn main() {
    let valid_json = r#"{
        "username": "johndoe",
        "email": "john.doe@example.com",
        "age": 30
    }"#;
    let invalid_json_type = r#"{
        "username": "janedoe",
        "email": "jane.doe@example.com",
        "age": "twenty five"
    }"#;

    match process_request_with_serde(valid_json) {
        Ok(req) => println!("Valid request parsed: {:?}", req),
        Err(e) => eprintln!("Error parsing valid JSON: {:?}", e),
    }

    match process_request_with_serde(invalid_json_type) {
        Ok(req) => println!("Invalid type request parsed: {:?}", req),
        Err(e) => eprintln!("Error parsing invalid type JSON: {:?}", e),
    }
}

main 함수에서 볼 수 있듯이, age가 숫자가 아닌 문자열로 제공되면 serde_json::from_str은 오류를 반환하여 타입 불일치를 우아하게 처리합니다. 이는 요청 파싱에 컴파일 타임 및 런타임 타입 안전성을 가져옵니다.

포괄적인 데이터 검증을 위한 validator 통합

serde는 데이터의 구조와 타입을 처리하지만 의미 규칙이나 비즈니스 로직을 강제하지는 않습니다. 여기서 validator가 등장합니다.

Cargo.toml에 validator를 추가합니다. 편의를 위해 derive 기능을 일반적으로 사용하고 싶을 것입니다.

[dependencies]
serde = { version = "1.0", features = ["derive"] }
serde_json = "1.0"
validator = { version = "0.18", features = ["derive"] }

이제 validator 속성을 사용하여 CreateUserRequest 구조체를 강화합니다.

use serde::Deserialize;
use validator::Validate; // Validate 트레잇 가져오기

#[derive(Debug, Deserialize, Validate)] // Validate 파생 매크로 추가
struct CreateUserRequest {
    #[validate(length(min = 3, max = 20, message = "Username must be between 3 and 20 characters"))]
    username: String,
    #[validate(email(message = "Email must be a valid email address"))]
    email: String,
    #[validate(range(min = 18, message = "User must be at least 18 years old"))]
    age: u32,
}

fn process_request_with_validation(json_data: &str) -> Result<CreateUserRequest, Box<dyn std::error::Error>> {
    let request: CreateUserRequest = serde_json::from_str(json_data)?;
    request.validate()?; // validate 메서드 호출
    Ok(request)
}

fn main() {
    let valid_user_json = r#"{
        "username": "johndoe",
        "email": "john.doe@example.com",
        "age": 30
    }"#;

    let invalid_user_json_too_young = r#"{
        "username": "janedoe",
        "email": "jane.doe@example.com",
        "age": 16
    }"#;

    let invalid_user_json_bad_email = r#"{
        "username": "peterp",
        "email": "peterp_at_example.com",
        "age": 25
    }"#;

    println!("---");
    match process_request_with_validation(valid_user_json) {
        Ok(req) => println!("Successfully processed: {:?}", req),
        Err(e) => eprintln!("Error: {:?}", e),
    }

    println!("\n---");
    match process_request_with_validation(invalid_user_json_too_young) {
        Ok(req) => println!("Successfully processed: {:?}", req),
        Err(e) => eprintln!("Validation Error: {:?}", e),
    }

    println!("\n---");
    match process_request_with_validation(invalid_user_json_bad_email) {
        Ok(req) => println!("Successfully processed: {:?}", req),
        Err(e) => eprintln!("Validation Error: {:?}", e),
    }
}

이 향상된 예제에서는 다음과 같습니다.

  1. CreateUserRequest 구조체에 #[derive(Validate)]를 추가합니다.
  2. 각 필드에 #[validate(...)] 속성을 사용하여 검증 규칙을 지정합니다.
    • length(min = 3, max = 20)는 사용자 이름이 문자 제한 내에 있는지 확인합니다.
    • email은 표준 이메일 형식을 확인합니다.
    • range(min = 18)는 나이가 최소 18세인지 확인합니다.
  3. Validate 트레잇에서 제공하는 validate() 메서드를 역직렬화 후에 호출합니다. 검증 규칙 중 하나라도 실패하면 validator::ValidationErrors 오류를 반환하므로, 이를 구조화하여 특정 오류 메시지로 클라이언트에게 반환할 수 있습니다.

웹 프레임워크와의 통합

이 패턴은 Axum 또는 Actix-web과 같은 인기 있는 Rust 웹 프레임워크와 완벽하게 통합됩니다. 이러한 프레임워크는 종종 serde를 사용하여 요청 본문을 자동으로 역직렬화하는 추출기를 제공하며, validator를 사용하여 검증하도록 확장할 수 있습니다.

Axum의 경우 사용자 지정 추출기를 만들 수 있습니다.

use axum::{
    async_trait,
    extract::{
        rejection::JsonRejection,
        FromRequest,
        Request,
    },
    http::StatusCode,
    response::{
        IntoResponse,
        Response,
    },
    Json,
};
use serde::de::DeserializeOwned;
use validator::Validate;

// 검증된 JSON을 위한 사용자 지정 추출기
pub struct ValidatedJson<T>(pub T);

#[async_trait]
impl<T, S>
    FromRequest<S>
    for ValidatedJson<T>
where
    T: DeserializeOwned + Validate,
    S: Send + Sync,
    Json<T>: FromRequest<S, Rejection = JsonRejection>,
{
    type Rejection = ServerError;

    async fn from_request(req: Request, state: &S) -> Result<Self, Self::Rejection> {
        let Json(value) = Json::<T>::from_request(req, state).await?;
        value.validate()?;
        Ok(ValidatedJson(value))
    }
}

// 검증 및 역직렬화 오류를 캡슐화하는 사용자 지정 오류 유형
pub enum ServerError {
    JsonRejection(JsonRejection),
    ValidationError(validator::ValidationErrors),
}

impl IntoResponse for ServerError {
    fn into_response(self) -> Response {
        match self {
            ServerError::JsonRejection(rejection) => rejection.into_response(),
            ServerError::ValidationError(errors) => {
                let error_messages: Vec<String> = errors
                    .field_errors()
                    .into_iter()
                    .flat_map(|(field, field_errors)| {
                        field_errors.iter().map(move |err| {
                            format!(                                "{}: {}",
                                field,
                                err.message.as_ref().unwrap_or(&"Invalid".to_string()),
                            )
                        })
                    })
                    .collect();

                (
                    StatusCode::UNPROCESSABLE_ENTITY,
                    Json(serde_json::json!({ "errors": error_messages }))),
                )
                    .into_response();
            }
        }
    }
}

// Axum 핸들러에서의 예제 사용 (관련 Axum 설정 필요)
#[axum::debug_handler]
async fn create_user(ValidatedJson(payload): ValidatedJson<CreateUserRequest>) -> impl IntoResponse {
    // 여기에 도달했다면 payload는 이미 역직렬화되고 검증되었습니다.
    println!("Received valid user creation request: {:?}", payload);
    (StatusCode::CREATED, Json(payload))
}

// CreateUserRequest는 이전과 같이 정의되어야 합니다.
#[derive(Debug, Deserialize, Validate, serde::Serialize)] // 응답을 위해 Serialize 추가
struct CreateUserRequest {
    #[validate(length(min = 3, max = 20, message = "Username must be between 3 and 20 characters"))]
    username: String,
    #[validate(email(message = "Email must be a valid email address"))]
    email: String,
    #[validate(range(min = 18, message = "User must be at least 18 years old"))]
    age: u32,
}

이 ValidatedJson 추출기는 들어오는 모든 JSON 요청 본문이 serde에 의해 역직렬화되고 validator에 의해 검증된 후에야 애플리케이션 로직에 도달하도록 보장합니다. 이는 오류 처리를 중앙 집중화하고 비즈니스 로직을 깔끔하게 유지합니다.

사용자 지정 검증 논리

내장 검증기만으로는 충분하지 않은 경우가 있습니다. validator는 사용자 지정 검증 함수를 허용합니다. 예를 들어, 사용자 이름이 고유한지 확인하기 위해 데이터베이스 확인이 필요할 수 있습니다.

use serde::Deserialize;
use validator::{Validate, ValidationError, ValidationErrors};

// 사용자 지정 검증자 함수
fn username_is_not_admin(username: &str) -> Result<(), ValidationError> {
    if username.to_lowercase() == "admin" {
        return Err(ValidationError::new("username_admin_reserved"));
    }
    Ok(())
}

#[derive(Debug, Deserialize, Validate)]
struct CreateUserRequestWithCustomValidation {
    #[validate(
        length(min = 3, max = 20, message = "Username must be between 3 and 20 characters"),
        custom = "username_is_not_admin" // 사용자 지정 검증자 사용
    )]
    username: String,
    #[validate(email(message = "Email must be a valid email address"))]
    email: String,
    #[validate(range(min = 18, message = "User must be at least 18 years old"))]
    age: u32,
}

fn main() {
    let admin_user_json = r#"{
        "username": "Admin",
        "email": "admin@example.com",
        "age": 40
    }"#;

    println!("\n---");
    let request: Result<CreateUserRequestWithCustomValidation, serde_json::Error> = serde_json::from_str(admin_user_json);
    
    if let Ok(req) = request {
        match req.validate() {
            Ok(_) => println!("Successfully processed: {:?}", req),
            Err(e) => {
                println!("Validation Error: {:?}", e);
                // 특정 사용자 지정 오류를 검사할 수 있습니다.
                if let Some(field_errors) = e.field_errors().get("username") {
                    for error in field_errors {
                        if error.code == "username_admin_reserved" {
                            println!("Specific error: Username 'admin' is reserved.");
                        }
                    }
                }
            }
        }
    } else if let Err(e) = request {
        eprintln!("Deserialization Error: {:?}", e);
    }
}

이는 validator가 내장된 검증기만큼 복잡하거나 도메인별 검증 규칙을 수용할 수 있을 만큼 유연하여 데이터 무결성 검사를 비즈니스 로직만큼 견고하게 만든다는 것을 보여줍니다.

결론

타입 안전한 역직렬화를 위한 serde와 표현력 있는 데이터 검증을 위한 validator의 조합은 Rust 웹 서비스에서 요청 본문을 처리하는 강력하고 우아한 솔루션을 제공합니다. 이러한 크레이트를 활용함으로써 개발자는 상당한 양의 상용구 코드를 줄이고, 코드 가독성을 향상시키며, 가장 중요한 것은 더 안전하고 안정적인 애플리케이션을 구축할 수 있습니다. 이 접근 방식은 시스템에 들어오는 데이터가 올바르게 구조화되었을 뿐만 아니라 필요한 모든 비즈니스 규칙을 준수하도록 보장하여, 애플리케이션을 최초 상호 작용부터 잘못된 입력과 예상치 못한 오류로부터 보호합니다. 타입 안전성과 견고한 검증은 Rust에서 잘 설계된 웹 서비스의 필수 불가결한 기둥입니다.

Share this article

HackerNews

More Posts from Leapcell

Popular Posts