DocsPricingBlog
Contact Us
Log inSign up for FREE
Back to Tech Articles

Axum、Actix Web、Diesel を使用した堅牢で高性能な REST API の構築

Sep 01, 2025
# Go

Takashi Yamamoto

Infrastructure Engineer · Leapcell

This post is also available in English, 한국어, and Deutsch
Cover of "Axum、Actix Web、Diesel を使用した堅牢で高性能な REST API の構築"

はじめに

ウェブ開発の急速に進化する状況において、高性能で信頼性が高く、保守性の高い API の需要はますます高まっています。最新のウェブアプリケーション、モバイルサービス、またはマイクロサービスアーキテクチャのバックエンドを構築する場合でも、テクノロジースタックの選択はプロジェクトの成功に大きく影響します。Rust は、パフォーマンス、メモリ安全性、同時実行性への比類なき注力により、バックエンド開発における魅力的な選択肢として浮上しています。この記事では、Rust で最も人気があり、しばしば議論される 2 つの Web フレームワーク、Axum と Actix Web、そして強力な ORM（オブジェクトリレーショナルマッパー）Diesel をどのように活用して、非常に高速であるだけでなく、優れた型安全性と保守性を誇る REST API を構築できるかを探ります。

この組み合わせの実践的な意義は計り知れません。パフォーマンスが重要なアプリケーションは、Rust のほぼゼロオーバーヘッドとコンパイル時の保証から恩恵を受け、実行時エラーを最小限に抑え、スループットを最大化します。Diesel によって強制される型安全性は、データベースのやり取りに関連するバグを減らすことを意味します。これは、データの不整合が本番環境で爆発するのではなく、コンパイル時に検出されるためです。さらに、これらのライブラリを取り巻く堅牢なエコシステムは、開発者に複雑でスケーラブルなシステムを自信を持って構築するために必要なツールを提供します。各テクノロジーのコアコンセプト、個々の強みを理解し、それらがどのようにエレガントに相互運用して、統一された強力なバックエンドソリューションを形成するかを実証します。

コアコンポーネントの理解

実装に入る前に、使用する主要なテクノロジー、Axum、Actix Web、Diesel の概念を明確に理解しましょう。

Axum

Axum は、Tokio 非同期ランタイムと Hyper HTTP ライブラリ上に構築された Web アプリケーションフレームワークです。Tokio コミュニティによって開発され、ルーティングとミドルウェアのために Rust の強力な型システムを採用した「マクロフリー」設計を特徴としています。Axum のコア哲学は、 composability（構成可能性）と標準 Rust トレイトの遵守を中心に展開しており、Rustaceans にとって非常に慣用的です。主な機能は次のとおりです。

  • 型安全なルーティング: ルートは、リクエストデータを解析し、型安全な方法で依存関係を注入するエクストラクタを受け取る関数として定義されます。これにより、不正確なデータ型による実行時エラーの可能性が減ります。
  • ミニマルで構成可能: Axum は、より小さな、構成可能なユニットからアプリケーションを構築することを推奨します。たとえば、ミドルウェアは、個々のルートまたはルートのグループに簡単に適用できます。
  • Tokio エコシステム統合: Tokio エコシステムのメンバーであるため、Axum は Tokio の堅牢な非同期ランタイム、優れた同時実行プリミティブ、および豊富なツールから恩恵を受けます。

Actix Web

Actix Web は、Rust 用の強力で実用的で非常に高速な Web フレームワークです。そのアクターベースの同時実行モデルで知られており、優れたパフォーマンス特性を持つ高度に並行なアプリケーションを可能にします。アクターモデルは複雑に聞こえるかもしれませんが、Actix Web はその使用を簡素化する高レベル API を提供します。その際立った特徴は次のとおりです。

  • 極限のパフォーマンス: Actix Web は、さまざまなベンチマークで最も高速な Web フレームワークの 1 つとして一貫してランク付けされています。これは、効率的なアクターモデルと最適化された内部アーキテクチャによるものです。
  • すぐに使える機能: Actix Web は、ルーティング、ミドルウェア、セッション、WebSockets、および強力なテストユーティリティを含む、包括的な機能セットをすぐに利用できます。
  • アクターベースの同時実行（抽象化）: アクターモデル上に構築されていますが、開発者は主に web::Service および web::Data コンポーネントとやり取りします。これらは、HTTP リクエストの同時処理に焦点を当て、基盤となる複雑さを大部分抽象化します。

Diesel

Diesel は、Rust 用の強力で型安全な ORM およびクエリビルダーです。リレーショナルデータベースとの安全で効率的な対話方法を提供することを目指しています。Diesel の主な強みは、データベーススキーマとクエリの有効性に関するコンパイル時の保証にあります。

  • コンパイル時の型安全性: Diesel は、データベーススキーマに直接対応する Rust 型を生成します。これは、存在しない列をクエリしたり、不正確な型の値を挿入しようとすると、コードのコンパイルができなくなることを意味し、多くの一般的な実行時エラーを防ぎます。
  • 強力なクエリビルダー: Diesel は、複雑な SQL クエリを型安全で慣用的な Rust の方法で構築するための表現力豊かなドメイン固有言語（DSL）を提供します。
  • マイグレーションシステム: Diesel には、データベーススキーマの進化を時間とともに管理するのに役立つ堅牢なマイグレーションシステムが含まれています。
  • 複数のデータベースのサポート: Diesel は、PostgreSQL、MySQL、SQLite をサポートしています。

なぜこれらを組み合わせるのか？

この組み合わせの利点は、各コンポーネントの強みを活用することにあります。Axum と Actix Web はどちらも HTTP リクエストとルーティングの処理に優れており、Axum はエクストラクタによるより明示的な型安全性を、Actix Web は生のパフォーマンスと機能豊富なエコシステムを提供します。一方、Diesel は、生の SQL を抽象化しながらパフォーマンスを維持しつつ、データベースとの型安全な対話の重要なレイヤーを提供します。この懸念事項の分離は、保守可能なコードにつながります。そこでは、Web ロジックがデータアクセスロジックと区別されており、どちらも Rust の強力な型システムによってサポートされています。

基本的な REST API の構築：ユーザーと投稿

ユーザーとその投稿を管理するための簡単な REST API の構築方法を説明します。両方に対して基本的な CRUD 操作を実装します。まずデータベーススキーマを定義し、次に Diesel ORM をセットアップし、最後に Axum および Actix Web と統合します。

Diesel によるデータベースセットアップ

まず、データベース（例：PostgreSQL）をセットアップする必要があります。マイグレーションを管理するために Diesel CLI を使用します。

1. Diesel CLI のインストール:

cargo install diesel_cli --no-default-features --features postgres

（別のデータベースを使用する場合は、postgres を mysql または sqlite に置き換えてください）。

2. Diesel の初期化: データベース URL を含む .env ファイルを作成します。

DATABASE_URL=postgres://user:password@localhost/your_database_name

次に、プロジェクトで Diesel を初期化します。

diesel setup

これにより migrations ディレクトリが作成されます。

3. マイグレーションの作成: users および posts テーブルを定義します。

diesel migration generate create_users

生成された up.sql ファイルを編集します。

-- migrations/timestamp_create_users/up.sql
CREATE TABLE users (
  id SERIAL PRIMARY KEY,
  username VARCHAR(255) NOT NULL UNIQUE,
  email VARCHAR(255) NOT NULL UNIQUE
);
diesel migration generate create_posts

生成された up.sql ファイルを編集します。

-- migrations/timestamp_create_posts/up.sql
CREATE TABLE posts (
  id SERIAL PRIMARY KEY,
  user_id INTEGER NOT NULL REFERENCES users(id),
  title VARCHAR(255) NOT NULL,
  body TEXT NOT NULL,
  published BOOLEAN NOT NULL DEFAULT FALSE
);

4. マイグレーションの実行:

diesel migration run

5. Diesel スキーマとモデルの生成: Cargo.toml に diesel と dotenvy を追加します。

[dependencies]
diesel = { version = "2.1.0", features = ["postgres", "r2d2", "chrono"] }
# 後で Axum/Actix Web、serde、anyhow なども追加

diesel print-schema を実行し、出力を src/schema.rs にコピーするか、diesel infer-schema > src/schema.rs を使用します。これにより、テーブルの Rust 表現が生成されます。

// src/schema.rs
// このファイルは Diesel CLI によって生成されます。

diesel::table! {
    posts (id) {
        id -> Int4,
        user_id -> Int4,
        title -> Varchar,
        body -> Text,
        published -> Bool,
    }
}

diesel::table! {
    users (id) {
        id -> Int4,
        username -> Varchr,
        email -> Varchar,
    }
}

diesel::joinable!(posts -> users (user_id));

diesel::allow_tables_to_appear_in_same_query!(
    posts,
    users,
);

次に、src/models.rs に Rust モデルと DTO を定義します。

// src/models.rs
use diesel::prelude::*;
use serde::{Deserialize, Serialize};
use crate::schema::{users, posts};

#[derive(Queryable, Selectable, Debug, Serialize)]
#[diesel(table_name = users)]
#[diesel(check_for_backend(diesel::pg::Pg))]
pub struct User {
    pub id: i32,
    pub username: String,
    pub email: String,
}

#[derive(Insertable, Deserialize)]
#[diesel(table_name = users)]
pub struct NewUser {
    pub username: String,
    pub email: String,
}

#[derive(Queryable, Selectable, Debug, Serialize)]
#[diesel(belongs_to(User))]
#[diesel(table_name = posts)]
#[diesel(check_for_backend(diesel::pg::Pg))]
pub struct Post {
    pub id: i32,
    pub user_id: i32,
    pub title: String,
    pub body: String,
    pub published: bool,
}

#[derive(Insertable, Deserialize)]
#[diesel(table_name = posts)]
pub struct NewPost {
    pub user_id: i32,
    pub title: String,
    pub body: String,
    pub published: Option<bool>, // オプション、DB では false にデフォルト
}

#[derive(Deserialize, Serialize)]
pub struct UpdatePost {
    pub title: Option<String>,
    pub body: Option<String>,
    pub published: Option<bool>,
}

データベース接続プーリング

パフォーマンスのために、r2d2 を接続プーリングに使用します。

// src/db_config.rs
use diesel::pg::PgConnection;
use diesel::r2d2::{ConnectionManager, Pool};
use std::env;

pub type PgPool = Pool<ConnectionManager<PgConnection>>;

pub fn establish_connection_pool() -> PgPool {
    dotenvy::dotenv().ok();
    let database_url = env::var("DATABASE_URL")
        .expect("DATABASE_URL must be set");
    let manager = ConnectionManager::<PgConnection>::new(database_url);
    Pool::builder()
        .max_size(10) // プール内の最大接続数
        .build(manager)
        .expect("Failed to create pool.")
}

Axum を使用した REST API エンドポイントの実装

次に、Axum を使用して API エンドポイントを構築しましょう。

1. Axum 用 Cargo.toml:

[dependencies]
axum = { version = "0.7.5", features = ["macros"] }
tokio = { version = "1.37.0", features = ["full"] }
serde = { version = "1.0.203", features = ["derive"] }
serde_json = "1.0.117"
diesel = { version = "2.1.0", features = ["postgres", "r2d2", "chrono"] }
r2d2 = "0.8.10"
anyhow = "1.0.83"
dotenvy = "0.15.7"

2. src/handlers_axum.rs での Axum API ハンドラ:

// src/handlers_axum.rs
use axum::{
    extract::{Path, State},
    http::StatusCode,
    response::{IntoResponse, Json},
    routing::{get, post, patch, delete},
    Router,
};
diesel::prelude::*;
diesel::r2d2::{ConnectionManager, Pool};
use serde_json::json;

use crate::models::{User, NewUser, Post, NewPost, UpdatePost};
use crate::schema::{users, posts};
use crate::db_config::PgPool;

pub type DbConnection = diesel::r2d2::PooledConnection<ConnectionManager<PgConnection>>;

// プールから接続を取得するヘルパー関数
async fn get_conn(pool: &PgPool) -> Result<DbConnection, (StatusCode, String)> {
    pool.get().map_err(|e| {
        (StatusCode::INTERNAL_SERVER_ERROR, format!("Failed to get DB connection: {}", e))
    })
}

// ユーザーハンドラ
pub async fn create_user(
    State(pool): State<PgPool>,
    Json(new_user): Json<NewUser>,
) -> Result<Json<User>, (StatusCode, String)> {
    let mut conn = get_conn(&pool).await?;

    let user = diesel::insert_into(users::table)
        .values(&new_user)
        .get_result::<User>(&mut conn)
        .map_err(|e| (StatusCode::INTERNAL_SERVER_ERROR, format!("Failed to create user: {}", e)))?;

    Ok(Json(user))
}

pub async fn get_all_users(
    State(pool): State<PgPool>,
) -> Result<Json<Vec<User>>, (StatusCode, String)> {
    let mut conn = get_conn(&pool).await?;

    let users_list = users::table
        .load::<User>(&mut conn)
        .map_err(|e| (StatusCode::INTERNAL_SERVER_ERROR, format!("Failed to fetch users: {}", e)))?;

    Ok(Json(users_list))
}

pub async fn get_user_by_id(
    State(pool): State<PgPool>,
    Path(user_id): Path<i32>,
) -> Result<Json<User>, (StatusCode, String)> {
    let mut conn = get_conn(&pool).await?;

    let user = users::table
        .find(user_id)
        .first::<User>(&mut conn)
        .map_err(|e| match e {
            diesel::result::Error::NotFound => (StatusCode::NOT_FOUND, "User not found".to_string()),
            _ => (StatusCode::INTERNAL_SERVER_ERROR, format!("Failed to get user: {}", e)),
        })?;

    Ok(Json(user))
}

// 投稿ハンドラ
pub async fn create_post(
    State(pool): State<PgPool>,
    Json(new_post): Json<NewPost>,
) -> Result<Json<Post>, (StatusCode, String)> {
    let mut conn = get_conn(&pool).await?;

    let post = diesel::insert_into(posts::table)
        .values(&new_post)
        .get_result::<Post>(&mut conn)
        .map_err(|e| (StatusCode::INTERNAL_SERVER_ERROR, format!("Failed to create post: {}", e)))?;

    Ok(Json(post))
}

pub async fn get_posts_by_user(
    State(pool): State<PgPool>,
    Path(user_id): Path<i32>,
) -> Result<Json<Vec<Post>>, (StatusCode, String)> {
    let mut conn = get_conn(&pool).await?;

    let user_posts = Post::belonging_to(&users::table.find(user_id).first::<User>(&mut conn)
            .map_err(|e| match e {
                diesel::result::Error::NotFound => (StatusCode::NOT_FOUND, "User not found for posts".to_string()),
                _ => (StatusCode::INTERNAL_SERVER_ERROR, format!("Failed to fetch user for posts: {}", e)),
            })?)
        .load::<Post>(&mut conn)
        .map_err(|e| (StatusCode::INTERNAL_SERVER_ERROR, format!("Failed to fetch posts: {}", e)))?;

    Ok(Json(user_posts))
}

pub async fn update_post(
    State(pool): State<PgPool>,
    Path(post_id): Path<i32>,
    Json(update_data): Json<UpdatePost>,
) -> Result<Json<Post>, (StatusCode, String)> {
    let mut conn = get_conn(&pool).await?;

    let updated_post: Post = diesel::update(posts::table.find(post_id))
        .set((
            update_data.title.map(|t| posts::title.eq(t)),
            update_data.body.map(|b| posts::body.eq(b)),
            update_data.published.map(|p| posts::published.eq(p)),
        ))
        .get_result::<Post>(&mut conn)
        .map_err(|e| match e {
            diesel::result::Error::NotFound => (StatusCode::NOT_FOUND, "Post not found".to_string()),
            _ => (StatusCode::INTERNAL_SERVER_ERROR, format!("Failed to update post: {}", e)),
        })?;

    Ok(Json(updated_post))
}

pub async fn delete_post(
    State(pool): State<PgPool>,
    Path(post_id): Path<i32>,
) -> Result<StatusCode, (StatusCode, String)> {
    let mut conn = get_conn(&pool).await?;

    let num_deleted = diesel::delete(posts::table.find(post_id))
        .execute(&mut conn)
        .map_err(|e| (StatusCode::INTERNAL_SERVER_ERROR, format!("Failed to delete post: {}", e)))?;

    if num_deleted == 0 {
        Err((StatusCode::NOT_FOUND, "Post not found".to_string()))
    } else {
        Ok(StatusCode::NO_CONTENT)
    }
}

3. src/main.rs のメイン関数 (Axum バージョン):

// src/main.rs (Axum version)
mod schema;
mod models;
mod db_config;
mod handlers_axum;

use axum::Router;
use axum::routing::get;
use crate::db_config::establish_connection_pool;
use crate::handlers_axum::{
    create_user, get_all_users, get_user_by_id,
    create_post, get_posts_by_user, update_post, delete_post
};

#[tokio::main]
async fn main() {
    let pool = establish_connection_pool();

    let app = Router::new()
        .route("/users", get(get_all_users).post(create_user))
        .route("/users/:user_id", get(get_user_by_id))
        .route("/users/:user_id/posts", get(get_posts_by_user))
        .route("/posts", post(create_post))
        .route("/posts/:post_id", patch(update_post).delete(delete_post))
        .with_state(pool);

    let listener = tokio::net::TcpListener::bind("0.0.0.0:3000").await.unwrap();
    println!("Axum server listening on http://0.0.0.0:3000");
    axum::serve(listener, app).await.unwrap();
}

Actix Web を使用した REST API エンドポイントの実装

次に、Actix Web を使用して同じ API エンドポイントを構築しましょう。

1. Actix Web 用 Cargo.toml:

[dependencies]
actix-web = "4.9.0"
actix-rt = "2.10.0" # `main` マクロ用
serde = { version = "1.0.203", features = ["derive"] }
serde_json = "1.0.117"
diesel = { version = "2.1.0", features = ["postgres", "r2d2", "chrono"] }
r2d2 = "0.8.10"
anyhow = "1.0.83"
dotenvy = "0.15.7"

2. src/handlers_actix.rs での Actix Web API ハンドラ:

// src/handlers_actix.rs
use actix_web::{web, HttpResponse, Responder};
diesel::prelude::*;
diesel::r2d2::{ConnectionManager, Pool};
use serde_json::json;

use crate::models::{User, NewUser, Post, NewPost, UpdatePost};
use crate::schema::{users, posts};
use crate::db_config::PgPool;

pub type DbConnection = diesel::r2d2::PooledConnection<ConnectionManager<PgConnection>>;

// プールから接続を取得するヘルパー関数
async fn get_conn_actix(pool: web::Data<PgPool>) -> Result<DbConnection, HttpResponse> {
    web::block(move || pool.get())
        .await
        .map_err(|e| HttpResponse::InternalServerError().body(format!("Failed to get DB connection: {}", e)))? \
        .map_err(|e| HttpResponse::InternalServerError().body(format!("Failed to get DB connection: {}", e)))
}

// ユーザーハンドラ
pub async fn create_user_actix(
    pool: web::Data<PgPool>,
    new_user: web::Json<NewUser>,
) -> impl Responder {
    let mut conn = match get_conn_actix(pool).await {
        Ok(c) => c,
        Err(e) => return e,
    };

    let user = web::block(move || {
        diesel::insert_into(users::table)
            .values(&new_user.into_inner())
            .get_result::<User>(&mut conn)
    })
    .await
    .map_err(|e| HttpResponse::InternalServerError().body(format!("Failed to create user: {}", e)))? \
    .map_err(|e| HttpResponse::InternalServerError().body(format!("Failed to create user: {}", e)))?;

    HttpResponse::Ok().json(user)
}

pub async fn get_all_users_actix(
    pool: web::Data<PgPool>,
) -> impl Responder {
    let mut conn = match get_conn_actix(pool).await {
        Ok(c) => c,
        Err(e) => return e,
    };

    let users_list = web::block(move || {
        users::table
            .load::<User>(&mut conn)
    })
    .await
    .map_err(|e| HttpResponse::InternalServerError().body(format!("Failed to fetch users: {}", e)))? \
    .map_err(|e| HttpResponse::InternalServerError().body(format!("Failed to fetch users: {}", e)))?;

    HttpResponse::Ok().json(users_list)
}

pub async fn get_user_by_id_actix(
    pool: web::Data<PgPool>,
    path: web::Path<i32>,
) -> impl Responder {
    let user_id = path.into_inner();
    let mut conn = match get_conn_actix(pool).await {
        Ok(c) => c,
        Err(e) => return e,
    };

    let user = web::block(move || {
        users::table
            .find(user_id)
            .first::<User>(&mut conn)
    })
    .await
    .map_err(|e| HttpResponse::InternalServerError().body(format!("Failed to get user: {}", e)))? \
    .map_err(|e| match e {
        diesel::result::Error::NotFound => HttpResponse::NotFound().body("User not found"),
        _ => HttpResponse::InternalServerError().body(format!("Failed to get user: {}", e)),
    })?;

    HttpResponse::Ok().json(user)
}

// 投稿ハンドラ
pub async fn create_post_actix(
    pool: web::Data<PgPool>,
    new_post: web::Json<NewPost>,
) -> impl Responder {
    let mut conn = match get_conn_actix(pool).await {
        Ok(c) => c,
        Err(e) => return e,
    };

    let post = web::block(move || {
        diesel::insert_into(posts::table)
            .values(&new_post.into_inner())
            .get_result::<Post>(&mut conn)
    })
    .await
    .map_err(|e| HttpResponse::InternalServerError().body(format!("Failed to create post: {}", e)))? \
    .map_err(|e| HttpResponse::InternalServerError().body(format!("Failed to create post: {}", e)))?;

    HttpResponse::Ok().json(post)
}

pub async fn get_posts_by_user_actix(
    pool: web::Data<PgPool>,
    path: web::Path<i32>,
) -> impl Responder {
    let user_id = path.into_inner();
    let mut conn = match get_conn_actix(pool).await {
        Ok(c) => c,
        Err(e) => return e,
    };

    let user_posts = web::block(move || {
        let user_found = users::table.find(user_id).first::<User>(&mut conn)?;
        Post::belonging_to(&user_found)
            .load::<Post>(&mut conn)
    })
    .await
    .map_err(|e| HttpResponse::InternalServerError().body(format!("Failed to fetch posts: {}", e)))? \
    .map_err(|e| match e {
        diesel::result::Error::NotFound => HttpResponse::NotFound().body("User not found for posts"),
        _ => HttpResponse::InternalServerError().body(format!("Failed to fetch posts: {}", e)),
    })?;

    HttpResponse::Ok().json(user_posts)
}

pub async fn update_post_actix(
    pool: web::Data<PgPool>,
    path: web::Path<i32>,
    update_data: web::Json<UpdatePost>,
) -> impl Responder {
    let post_id = path.into_inner();
    let mut conn = match get_conn_actix(pool).await {
        Ok(c) => c,
        Err(e) => return e,
    };

    let updated_post: Post = web::block(move || {
        diesel::update(posts::table.find(post_id))
            .set((
                update_data.title.map(|t| posts::title.eq(t)),
                update_data.body.map(|b| posts::body.eq(b)),
                update_data.published.map(|p| posts::published.eq(p)),
            ))
            .get_result::<Post>(&mut conn)
    })
    .await
    .map_err(|e| HttpResponse::InternalServerError().body(format!("Failed to update post: {}", e)))? \
    .map_err(|e| match e {
        diesel::result::Error::NotFound => HttpResponse::NotFound().body("Post not found"),
        _ => HttpResponse::InternalServerError().body(format!("Failed to update post: {}", e)),
    })?;

    HttpResponse::Ok().json(updated_post)
}

pub async fn delete_post_actix(
    pool: web::Data<PgPool>,
    path: web::Path<i32>,
) -> impl Responder {
    let post_id = path.into_inner();
    let mut conn = match get_conn_actix(pool).await {
        Ok(c) => c,
        Err(e) => return e,
    };

    let num_deleted = web::block(move || {
        diesel::delete(posts::table.find(post_id))
            .execute(&mut conn)
    })
    .await
    .map_err(|e| HttpResponse::InternalServerError().body(format!("Failed to delete post: {}", e)))? \
    .map_err(|e| HttpResponse::InternalServerError().body(format!("Failed to delete post: {}", e)))?;

    if num_deleted == 0 {
        HttpResponse::NotFound().body("Post not found")
    } else {
        HttpResponse::NoContent().finish()
    }
}

3. src/main.rs のメイン関数 (Actix Web バージョン):

// src/main.rs (Actix Web version)
mod schema;
mod models;
mod db_config;
mod handlers_actix;

use actix_web::{web, App, HttpServer};
use crate::db_config::establish_connection_pool;
use crate::handlers_actix::{
    create_user_actix, get_all_users_actix, get_user_by_id_actix,
    create_post_actix, get_posts_by_user_actix, update_post_actix, delete_post_actix
};

#[actix_web::main]
async fn main() -> std::io::Result<()> {
    let pool = establish_connection_pool();
    let pool_data = web::Data::new(pool); // プールを web::Data でラップ

    println!("Actix Web server listening on http://0.0.0.0:3000");

    HttpServer::new(move || {{
        App::new()
            .app_data(pool_data.clone()) // 共有データをルートに渡す
            .service(
                web::resource("/users")
                    .route(web::get().to(get_all_users_actix))
                    .route(web::post().to(create_user_actix))
            )
            .service(web::resource("/users/{user_id}").route(web::get().to(get_user_by_id_actix)))
             .service(web::resource("/users/{user_id}/posts").route(web::get().to(get_posts_by_user_actix)))
            .service(web::resource("/posts").route(web::post().to(create_post_actix)))
            .service(
                web::resource("/posts/{post_id}")
                    .route(web::patch().to(update_post_actix))
                    .route(web::delete().to(delete_post_actix))
            )
    }})
    .bind(("0.0.0.0", 3000))?;
    .run()
    .await
}

注意: Axum と Actix Web を切り替えるには、一方の main 関数をコメントアウトし、もう一方をコメント解除して、Cargo.toml の依存関係を調整してください。

アプリケーションシナリオとメリット

この例は、ブログプラットフォームまたはコンテンツ管理システムのための典型的な REST API バックエンドを示しています。主なメリットは次のとおりです。

  1. パフォーマンス: Axum と Actix Web はどちらも、Tokio の非同期ランタイムによってサポートされており、同時 HTTP リクエストを処理するための例外的な生のパフォーマンスを提供します。データベース操作は r2d2 接続プーリングによって効率的に管理され、ボトルネックを防ぎます。
  2. 型安全性: Diesel のコンパイル時チェックは、API ハンドラがデータベースと正しくやり取りすることを保証します。 NewUser、User、NewPost、Post、および UpdatePost 構造体は、データベース操作と JSON ペイロードに直接マッピングされ、実行時の型エラーを最小限に抑えます。スキーマまたはクエリ構造の不一致はコンパイルエラーにつながり、バグを早期に検出します。
  3. 保守性: Web フレームワークロジック（ルーティング、リクエスト処理）とデータベース操作ロジック（Diesel クエリ）の明確な分離により、コードベースは整理され、保守が容易になります。ハンドラはデータフローのオーケストレーションに焦点を当て、Diesel は SQL の複雑さを処理します。
  4. スケーラビリティ: Rust のメモリ効率と Axum/Actix Web の非同期性は、これらのサービスが最小限のリソース消費で大量の同時接続を処理できるようにするため、高トラフィックアプリケーションに最適です。
  5. 堅牢性: Rust の所有権システムと借用チェッカーは、ヌルポインタ逆参照やデータ競合などの一般的なバグクラスを排除し、より堅牢で信頼性の高いサービスにつながります。

結論

Diesel とともに Axum または Actix Web を使用して Rust で REST API を構築することは、パフォーマンス、型安全性、信頼性を求める開発者にとって、強力な組み合わせです。このスタックにより、非常に高速であるだけでなく、回復力があり、保守が容易なバックエンドサービスを作成できます。潜在的なエラーの大部分をコンパイル時に検出することにより、Rust、Axum/Actix Web、および Diesel は collectively、バックエンドインフラストラクチャに期待できるものを引き上げます。この相乗的なアプローチは、Web 開発における Rust の可能性を真に解き放ち、速度と正確さの両方の点で達成可能なものの境界を押し広げます。

Share this article

HackerNews

More Posts from Leapcell

Popular Posts