9 thư viện Rust hiệu năng cao không nên bỏ lỡ

Khi xây dựng các hệ thống backend hiệu năng cao và đáng tin cậy, thư viện chuẩn của Rust được thiết kế tinh gọn nên không tích hợp sẵn Web framework, trình điều khiển cơ sở dữ liệu hay các công cụ tuần tự hóa phức tạp. Thiết kế này giao quyền lựa chọn cho các nhà phát triển. Sau nhiều năm cộng đồng liên tục cải tiến, một số thư viện đã trở nên nổi bật và trở thành tiêu chuẩn thực tế (de facto) trong môi trường sản xuất.

Dưới đây là 9 thư viện cốt lõi mà bạn nên ưu tiên cân nhắc khi phát triển các dự án backend bằng Rust, chúng thực sự rất mạnh mẽ.

1. Serde và Serde_json

Dữ liệu di chuyển trong mạng thường cần được chuyển đổi định dạng. Serde áp dụng thiết kế trừu tượng hóa chi phí bằng không (zero-cost abstraction), tạo mã tuần tự hóa và giải tuần tự hóa trong giai đoạn biên dịch, giúp tránh lãng phí hiệu năng (reflection) khi chạy. Kết hợp với serde_json, việc xử lý dữ liệu JSON sẽ trở nên rất tự nhiên.

use serde::{Deserialize, Serialize};

#[derive(Serialize, Deserialize)]
struct UserProfile {
    #[serde(rename = "username")]
    name: String,
    // Bỏ qua các trường rỗng để giữ kết quả gọn gàng
    #[serde(skip_serializing_if = "Option::is_none")]
    nickname: Option<String>,
}

fn handle_json() {
    let data = r#"{"username": "rust_dev"}"#;
    let user: UserProfile = serde_json::from_str(data).expect("Phân tích thất bại");
    let output = serde_json::to_string(&user).unwrap();
}

2. Tower-http

Nếu bạn sử dụng Web framework như Axum, Tower-http là một thành phần không thể thiếu. Nó cung cấp một loạt các middleware có sẵn để xử lý các logic HTTP phổ biến như CORS, nén yêu cầu, kiểm soát thời gian chờ (timeout), v.v.

Nó có thể tăng cường chức năng dịch vụ bằng cách kết hợp các lớp (Layer) khác nhau. Ví dụ, việc bật hỗ trợ nén và chính sách CORS chỉ cần vài dòng cấu hình.

use tower_http::{cors::Any, cors::CorsLayer, compression::CompressionLayer};
use axum::Router; // Giả sử sử dụng axum

let app = Router::new()
    .route("/", get(|| async { "ok" }))
    .layer(CorsLayer::new().allow_origin(Any))
    .layer(CompressionLayer::new());

3. Sea-ORM

Sea-ORM là một framework ORM bất đồng bộ được xây dựng dựa trên SQLx. Đối với các nhà phát triển đã quen với ORM của các ngôn ngữ động (như Django hoặc ActiveRecord), Sea-ORM cung cấp giao diện truy vấn chuỗi (chain query) thân thiện hơn. Nó hỗ trợ tự động tạo các lớp thực thể (entity) và xử lý tốt các truy vấn liên kết phức tạp, đồng thời giữ nguyên lợi thế của việc thực thi bất đồng bộ.

use sea_orm::{entity::*, query::*, Database};

// Tìm tất cả người dùng có trạng thái là active
async fn get_active_users(db: &DatabaseConnection) -> Vec<user::Model> {
    user::Entity::find()
        .filter(user::Column::Status.eq("active"))
        .all(db)
        .await
        .unwrap_or_default()
}

4. JSONWebToken

Trong các REST API không trạng thái (stateless), JWT là giải pháp phổ biến cho việc xác thực. Thư viện này triển khai logic ký và xác thực JWT, hỗ trợ nhiều thuật toán như HS256, RS256. Khi kết hợp với Serde, bạn có thể ánh xạ trực tiếp các Claims tùy chỉnh thành các cấu trúc Rust.

use jsonwebtoken::{encode, Header, EncodingKey};
use serde::{Serialize, Deserialize};

#[derive(Debug, Serialize, Deserialize)]
struct TokenClaims {
    sub: String,
    exp: usize,
}

fn create_token(user_id: &str) -> String {
    let claims = TokenClaims { sub: user_id.to_owned(), exp: 10000000000 };
    encode(&Header::default(), &claims, &EncodingKey::from_secret("secret".as_ref())).unwrap()
}

5. Argon2

Khi lưu trữ mật khẩu người dùng, việc lựa chọn thuật toán băm bảo mật là rất quan trọng. Argon2 là thuật toán hiện đại được khuyên dùng hiện nay, nó chống lại việc phá mã bằng cách tăng chi phí bộ nhớ và tính toán. Thư viện argon2 của Rust rất dễ sử dụng và có thể ngăn chặn hiệu quả các cuộc tấn công bảng cầu vồng (rainbow table).

use argon2::{Argon2, PasswordHasher, PasswordVerifier, password_hash::SaltString};
use argon2::password_hash::rand_core::OsRng;

fn secure_password() {
    let pwd = b"my_password";
    let salt = SaltString::generate(&mut OsRng);
    let argon2 = Argon2::default();
    let hash = argon2.hash_password(pwd, &salt).unwrap().to_string();
    
    // Logic xác thực
    let parsed_hash = argon2::PasswordHash::new(&hash).unwrap();
    assert!(argon2.verify_password(pwd, &parsed_hash).is_ok());
}

6. Prometheus

Khả năng quan sát (observability) là yêu cầu bắt buộc trong môi trường sản xuất. Thư viện prometheus cho phép bạn thu thập các chỉ số như thời gian phản hồi yêu cầu, số lượng kết nối đồng thời, tần suất lỗi, v.v. Những dữ liệu này có thể được Prometheus thu thập và hiển thị trong Grafana, giúp nhà phát triển nắm bắt trạng thái hoạt động của hệ thống.

use prometheus::{Counter, Registry};

lazy_static::lazy_static! {
    static ref HTTP_REQUESTS: Counter = Counter::new("http_requests", "Tổng số yêu cầu").unwrap();
}

fn track_metric() {
    HTTP_REQUESTS.inc();
}

7. Tokio-cron-scheduler

Các dịch vụ backend thường cần xử lý các tác vụ định kỳ, chẳng hạn như quyết toán hàng ngày, dọn dẹp bộ nhớ đệm hết hạn, v.v. Thư viện này tích hợp biểu thức Cron vào runtime bất đồng bộ Tokio, cho phép kích hoạt các hàm bất đồng bộ theo lịch trình đã đặt trước mà không làm tắc nghẽn luồng chính.

use tokio_cron_scheduler::{Job, JobScheduler};

async fn start_scheduler() {
    let sched = JobScheduler::new().await.unwrap();
    sched.add(Job::new("0 0 1 * * *", |_, _| {
        println!("Thực hiện dọn dẹp vào 1 giờ sáng hàng ngày");
    }).unwrap()).await.unwrap();
    sched.start().await.unwrap();
}

8. Async-graphql

Nếu bạn cần xây dựng giao diện GraphQL, async-graphql hiện là lựa chọn hàng đầu. Nó tận dụng hệ thống kiểu của Rust để định nghĩa Schema, có thể tự động tạo tài liệu và hỗ trợ chức năng Subscription mạnh mẽ (đẩy dữ liệu thời gian thực dựa trên WebSocket). Nó có thể tích hợp liền mạch vào Axum hoặc Actix-web.

use async_graphql::{Object, Schema, EmptyMutation, EmptySubscription};

struct Query;

#[Object]
impl Query {
    async fn version(&self) -> &str { "v1.0" }
}

fn build_schema() {
    let schema = Schema::build(Query, EmptyMutation, EmptySubscription).finish();
}

9. Mockall

Kiểm thử là nền tảng để đảm bảo chất lượng mã. mockall có thể tạo các đối tượng Mock cho Trait, điều này rất hữu ích trong kiểm thử đơn vị (unit test). Bằng cách mô phỏng hành vi của API bên ngoài hoặc cơ sở dữ liệu, bạn có thể thực hiện kiểm thử cô lập thực sự, đảm bảo các nhánh logic được bao phủ hoàn toàn.

use mockall::{automock, predicate::*};

#[automock]
trait ExternalApi {
    fn fetch_data(&self, id: u32) -> String;
}

#[test]
fn test_business_logic() {
    let mut mock = MockExternalApi::new();
    mock.expect_fetch_data()
        .with(eq(10))
        .returning(|_| "mocked_value".to_string());
        
    assert_eq!(mock.fetch_data(10), "mocked_value");
}

Việc cấu hình môi trường phát triển Rust đôi khi liên quan đến các biến môi trường, phiên bản trình biên dịch cũng như cài đặt các thư viện cơ sở liên quan. Nếu sử dụng ServBay để triển khai Rust chỉ với một cú nhấp chuột, bạn sẽ không cần phải quan tâm đến những thứ rắc rối đó nữa.

ServBay là một công cụ quản lý môi trường phát triển cục bộ được thiết kế dành riêng cho các nhà phát triển. Nó tích hợp hỗ trợ trực tiếp cho môi trường Rust, cho phép cài đặt nhanh trình biên dịch Rust cũng như các môi trường cơ sở dữ liệu đi kèm như PostgreSQL, Redis, v.v., ngay trong giao diện đồ họa.

Tổng kết

9 thư viện trên bao quát toàn bộ quy trình từ xử lý dữ liệu, xác thực danh tính đến vận hành và giám sát. Hầu như mọi thứ cần thiết trong quá trình phát triển đều được đáp ứng, giúp tiết kiệm thời gian, công sức và giảm bớt lo âu.