Кратко про библиотеку Axum в Rust30.04.2024 12:00

MyExtractor извлекает данные из запроса, превращая их в структуру с полем value.

После создания extractor, его можно использовать в обработчиках запросов для получения данных:

async fn handle_request(custom: MyExtractor) -> String {
    format!("Extracted value: {}", custom.value)
}

Можно также создать условные extractor, которые могут принимать или отклонять запросы на основе содержимого запроса. Например, можно обернуть extractor в Option или Result, чтобы обрабатывать возможные ошибки извлечения данных:

async fn handle_optional_data(data: Option) -> String {
    match data {
        Some(extractor) => format!("Received data: {}", extractor.value),
        None => "No data received".to_string(),
    }
}

Интеграция с БД

Сложно представить хороший веб-фреймворк без работы с БД.

Интеграция БД в Axum можно провести с SQLx. Все начинается с настройки зависимостей в Cargo.toml. Пример конфигурации для работы с PostgreSQL:

[dependencies]
sqlx = { version = "0.5.5", features = ["postgres"] }
tokio = { version = "1.0", features = ["full"] }

Для работы с БД создается пул соединений, который затем может быть интегрирован в приложение Axum. Пример создания пула соединений и его передачи в обработчик запросов:

use axum::{Router, routing::get, Extension};
use sqlx::postgres::PgPool;
use std::net::SocketAddr;

async fn get_users(Extension(pool): Extension) -> String {
    // пример запроса к базе данных
    let users = sqlx::query!("SELECT username FROM users")
        .fetch_all(&pool)
        .await
        .unwrap();

    // обработка и возврат результатов
    format!("Found users: {:?}", users)
}

#[tokio::main]
async fn main() {
    let pool = PgPool::connect("postgres://user:password@localhost/database").await.unwrap();
    let app = Router::new().route("/users", get(get_users)).layer(Extension(pool));

    let addr = SocketAddr::from(([127, 0, 0, 1], 3000));
    axum::Server::bind(&addr)
        .serve(app.into_make_service())
        .await
        .unwrap();
}

Реализуем REST API с Axum

Для начала создадим проект Rust:

cargo new axum_rest_api
cd axum_rest_api

Добавим зависимости в файл Cargo.toml:

[dependencies]
axum = "0.6"
tokio = { version = "1.0", features = ["full"] }
serde = { version = "1.0", features = ["derive"] }
serde_json = "1.0"
sqlx = { version = "0.6", features = ["postgres"] }
dotenv = "0.15"

В src/main.rs настроим базовую асинхронную среду:

use axum::{
    routing::get,
    Router,
};
use std::net::SocketAddr;

#[tokio::main]
async fn main() {
    let app = Router::new().route("/", get(root_handler));

    let addr = SocketAddr::from(([127, 0, 0, 1], 3000));
    println!("Listening on {}", addr);
    axum::Server::bind(&addr)
        .serve(app.into_make_service())
        .await
        .unwrap();
}

async fn root_handler() -> &'static str {
    "Hello, HABR!"
}

Добавим поддержку dotenv для управления переменными окружения:

dotenv::dotenv().ok();
let database_url = std::env::var("DATABASE_URL").expect("DATABASE_URL must be set");

Юзаем sqlx для подключения к базе данных:

let db_pool = sqlx::PgPool::connect(&database_url).await.unwrap();

Определим маршруты для CRUD-операций:

let app = Router::new()
    .route("/", get(root_handler))
    .route("/users", get(get_users).post(add_user))
    .route("/users/:id", get(get_user).put(update_user).delete(delete_user))
    .layer(Extension(db_pool));

Обработчики для каждого маршрута:

async fn get_users(Extension(db_pool): Extension) -> impl IntoResponse {
    match sqlx::query_as!(User, "SELECT * FROM users")
        .fetch_all(&db_pool)
        .await
    {
        Ok(users) => (StatusCode::OK, Json(users)),
        Err(_) => (
            StatusCode::INTERNAL_SERVER_ERROR,
            Json(json!({"error": "Failed to fetch users"}))
        ),
    }
} // обработка результатов 

async fn add_user(Json(payload): Json, Extension(db_pool): Extension) -> impl IntoResponse {
    let query = "INSERT INTO users (name, email) VALUES ($1, $2) RETURNING id, name, email";
    match sqlx::query_as!(User, query, payload.name, payload.email)
        .fetch_one(&db_pool)
        .await
    {
        Ok(user) => (StatusCode::CREATED, Json(user)),
        Err(_) => (
            StatusCode::INTERNAL_SERVER_ERROR,
            Json(json!({"error": "Failed to add user"}))
        ),
    }
} // добавление юзеров

Для работы с БД юзаем SQLx, который поддерживает асинхронные запросы и предоставляет безопасные по типам запросы:

let user = sqlx::query_as!(User, "INSERT INTO users (name, email) VALUES ($1, $2) RETURNING id, name, email", &payload.name, &payload.email)
    .fetch_one(&db_pool)
    .await
    .unwrap();

Примерно так будет выглядеть базовое REST API на Axum в Rust.

Как вам библиотека? Знаете аналоги получше?

Напомню, что про другие интересные и полезные библиотеки мои коллеги из OTUS рассказывают в рамках практических онлайн-курсов. С каталогом курсов можно ознакомиться по ссылке.

© Habrahabr.ru