Rust言語 2025 - エンタープライズ採用が加速するシステムプログラミング言語

Rustがエンタープライズの壁を越えた年

2025年、Rustは「静かにエンタープライズの壁を越えた」と言われています。2021年から2024年の間に商用利用が68.75%増加し、Fortune 500企業がインフラをRustに賭けています。

採用状況

開発者コミュニティ

Big Tech企業の採用

• AWS: Firecracker（microVM）をRustで開発
• Microsoft: Windowsの低レベルコンポーネント
• Google: Androidのセキュリティ重要コンポーネント
• Meta: インフラストラクチャツール
• Linux Kernel: 公式サポート言語に追加

業界別採用率

金融サービス

• トレーディングシステム: 40%
• リスク管理システム: 35%
• 決済処理: 25%

その他の産業

Rustの強み

メモリ安全性

// Rustの所有権システムによるメモリ安全性
fn main() {
    let s1 = String::from("hello");
    let s2 = s1; // s1の所有権がs2に移動

    // println!("{}", s1); // コンパイルエラー！
    println!("{}", s2); // OK
}

並行処理の安全性

use std::thread;
use std::sync::Arc;

fn main() {
    let data = Arc::new(vec![1, 2, 3]);

    let handles: Vec<_> = (0..3).map(|i| {
        let data = Arc::clone(&data);
        thread::spawn(move || {
            println!("Thread {}: {:?}", i, data);
        })
    }).collect();

    for handle in handles {
        handle.join().unwrap();
    }
}

ゼロコスト抽象化

// イテレータは実行時オーバーヘッドなし
let sum: i32 = (1..=100)
    .filter(|x| x % 2 == 0)
    .map(|x| x * x)
    .sum();

Webフレームワークの成熟

2025年、RustのWebフレームワークはエンタープライズ対応レベルに到達。

主要フレームワーク

// Axumの例
use axum::{routing::get, Router, Json};
use serde::Serialize;

#[derive(Serialize)]
struct User {
    id: u64,
    name: String,
}

async fn get_user() -> Json<User> {
    Json(User {
        id: 1,
        name: "Alice".to_string(),
    })
}

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

    let listener = tokio::net::TcpListener::bind("0.0.0.0:3000")
        .await.unwrap();
    axum::serve(listener, app).await.unwrap();
}

フレームワーク比較

2025年の重点領域

Rustは2025年前半、新機能よりもコンパイラフラグとツールの安定化に注力。これはエンタープライズが求めていた成熟志向のシフトです。

改善されたコンパイル時間

# 増分コンパイルの改善
$ cargo build
   Compiling my-project v0.1.0
    Finished dev [unoptimized + debuginfo] target(s) in 2.34s

# 以前より大幅に高速化

学習リソース

公式ドキュメント

# Rustのインストール
curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh

# The Rust Book（公式チュートリアル）
rustup doc --book

推奨学習パス

1. The Rust Programming Language（公式Book）
2. Rustlings（インタラクティブ演習）
3. Rust by Example（実践例）
4. Async Rust（非同期プログラミング）

課題と今後

現在の課題

• 学習曲線: 所有権システムの理解に時間が必要
• コンパイル時間: 改善されたが依然として課題
• エコシステム: 一部領域でライブラリが不足

今後の展望

• クラウド、AI、組み込みシステムへの拡大
• WebAssemblyとの連携強化
• より高速なコンパイラの開発

参考: JetBrains - Is Rust the Future of Programming?

まとめ

2025年、Rustは実験的な言語からエンタープライズスタンダードへと進化しました。メモリ安全性、パフォーマンス、並行処理の安全性という強みが、金融、通信、自動車など要求の厳しい業界で評価されています。学習コストは高いものの、長期的な生産性とコード品質の向上が期待できます。

背景 - Rustがエンタープライズに選ばれる理由

メモリ安全性の欠如はC/C++由来の脆弱性の根本原因とされ、MicrosoftもGoogleも「自社製品の脆弱性の約70%がメモリ安全性に関するもの」と公表しています。Rustは所有権 (ownership)、借用 (borrowing)、ライフタイム (lifetime) という仕組みで、GC (ガベージコレクション) なしにメモリ安全性を保証し、かつC++並のパフォーマンスを実現する唯一の主流言語です。

2024年には米政府 (ONCD) が「メモリ安全な言語への移行」を推奨するレポートを公開し、Linuxカーネルや Windows カーネルにRustコードが採用されました。2025年はこの流れが決定的になり、エンタープライズ採用が加速しています。

主要トレンド詳細

1. async エコシステムの成熟

Tokio、async-std、Smol といった非同期ランタイムの競争はTokio勝利でほぼ決着し、標準的な async/await パターンが確立されました。

use tokio::time::{sleep, Duration};

#[tokio::main]
async fn main() {
    let tasks: Vec<_> = (0..5).map(|i| {
        tokio::spawn(async move {
            sleep(Duration::from_millis(100 * i)).await;
            println!("task {} done", i);
            i * 2
        })
    }).collect();

    for t in tasks {
        let result = t.await.unwrap();
        println!("got {}", result);
    }
}

2. Rust for Linux

Linuxカーネル6.1でRustサポートが入り、6.8以降ではドライバが続々とRustで書かれています。Nvidia の新GPUドライバ Nova や Apple Silicon GPU ドライバ (asahi) などが代表例。

// Simplified Linux kernel module in Rust
use kernel::prelude::*;

module! {
    type: HelloWorld,
    name: "hello_world",
    author: "Rust Developer",
    description: "A simple hello world module",
    license: "GPL",
}

struct HelloWorld;

impl kernel::Module for HelloWorld {
    fn init(_module: &'static ThisModule) -> Result<Self> {
        pr_info!("Hello from Rust kernel module!\n");
        Ok(HelloWorld)
    }
}

impl Drop for HelloWorld {
    fn drop(&mut self) {
        pr_info!("Goodbye from Rust kernel module!\n");
    }
}

3. WebAssembly での独走

Rustは WebAssembly ターゲットで最も成熟した言語です。Cloudflare Workers、Fastly Compute@Edge、wasmtime, Spin など WASM ランタイムの多くがRust製です。

use wasm_bindgen::prelude::*;

#[wasm_bindgen]
pub fn fibonacci(n: u32) -> u64 {
    match n {
        0 => 0,
        1 => 1,
        _ => {
            let (mut a, mut b) = (0u64, 1u64);
            for _ in 0..n - 1 {
                let tmp = a + b;
                a = b;
                b = tmp;
            }
            b
        }
    }
}

wasm-pack build --target web

4. CLIツールの席巻

Rust製CLIが開発者の日常を占領しつつあります。ripgrep, fd, bat, exa/eza, zoxide, starship, bottom, tokei, delta など。

use clap::Parser;

#[derive(Parser)]
#[command(name = "greet", about = "Greets a person")]
struct Cli {
    /// Name of the person to greet
    name: String,
    /// Number of times to greet
    #[arg(short, long, default_value_t = 1)]
    count: u8,
}

fn main() {
    let cli = Cli::parse();
    for _ in 0..cli.count {
        println!("Hello, {}!", cli.name);
    }
}

5. データエンジニアリング (Polars, DataFusion)

Rust製の列指向データフレーム Polars は Pandas の10倍以上高速とされ、Apache Arrow 準拠で Python/Node からも利用できます。

use polars::prelude::*;

fn main() -> Result<(), PolarsError> {
    let df = CsvReader::from_path("sales.csv")?.finish()?;
    let result = df
        .lazy()
        .filter(col("region").eq(lit("JP")))
        .group_by([col("product")])
        .agg([col("amount").sum().alias("total")])
        .sort("total", SortOptions::default().with_order_descending(true))
        .collect()?;
    println!("{:?}", result);
    Ok(())
}

実践サンプル - HTTPクライアントとエラー処理

use reqwest::Client;
use serde::Deserialize;
use thiserror::Error;

#[derive(Debug, Error)]
enum AppError {
    #[error("network error: {0}")]
    Network(#[from] reqwest::Error),
    #[error("parse error: {0}")]
    Parse(#[from] serde_json::Error),
}

#[derive(Debug, Deserialize)]
struct GithubRepo {
    full_name: String,
    stargazers_count: u64,
    description: Option<String>,
}

async fn fetch_repo(owner: &str, repo: &str) -> Result<GithubRepo, AppError> {
    let url = format!("https://api.github.com/repos/{owner}/{repo}");
    let client = Client::builder()
        .user_agent("rust-example/1.0")
        .build()?;
    let repo = client.get(&url).send().await?.json::<GithubRepo>().await?;
    Ok(repo)
}

#[tokio::main]
async fn main() -> Result<(), AppError> {
    let repo = fetch_repo("rust-lang", "rust").await?;
    println!("{}: {} stars", repo.full_name, repo.stargazers_count);
    if let Some(desc) = repo.description {
        println!("  {}", desc);
    }
    Ok(())
}

他言語との比較

ベストプラクティス

1. clippy を CI で必須化: cargo clippy -- -D warnings でコード品質を底上げ。
2. rustfmt で統一: フォーマットは議論の余地なし、自動化する。
3. エラー型には thiserror / anyhow: ライブラリは thiserror、アプリは anyhow が定番。
4. #[must_use] を積極的に: 戻り値の無視を防ぐ。
5. unsafe は最小化: 使う場合は // SAFETY: コメントで理由を明記。
6. cargo deny でライセンス監査: 依存ツリーのライセンスと既知脆弱性をチェック。
7. cargo nextest で高速テスト: 大規模テストスイートは標準の cargo test より数倍速くなる。
8. tokio::select! でタイムアウト: 非同期処理は必ずタイムアウトを付ける。

注意点・落とし穴

• 所有権の戦い: 最初は borrow checker に苦しむ。Clone や Rc<RefCell<T>> に頼りすぎると利点が失われる。
• async のウイルス的伝播: async fn は呼び出し元もすべて async にしたくなる。境界設計を意識する。
• コンパイル時間: 大規模プロジェクトでは数分〜十数分かかる。sccache、分割クレート化、--release を開発中は避けるなどで対策。
• バイナリサイズ: デフォルトでは大きい。strip = true, lto = true, opt-level = "z" などで削減。
• マクロの黒魔術: 手続き型マクロは便利だが、デバッグが困難。

導入手順

1. rustup でインストール (curl ... | sh)。
2. cargo new my-project でプロジェクト作成。
3. エディタに rust-analyzer を導入 (VS Code / Neovim / JetBrains)。
4. Cargo.toml に必要なクレートを追加 (cargo add tokio reqwest serde)。
5. cargo clippy, cargo fmt, cargo test を CI に組み込む。
6. 本番ビルドは cargo build --release に LTO と strip を有効化。
7. 運用では tracing + opentelemetry で可観測性を確保。

パフォーマンス・ベンチマーク

TechEmpower Web Framework Benchmarks の plaintext テストでは、Actix Web / Axum / Rocket といったRust系フレームワークは常にトップ10に入り、Go の net/http や Node.js の Fastify を上回るスループットを出します。これは GC 停止時間がないこと、ゼロコスト抽象化、効率的なスレッディングモデルの賜物です。

ただし、ベンチマーク結果はワークロードに依存します。JSONパース、DB I/O、外部API呼び出しが支配的なワークロードでは、言語間差は小さくなります。Rustの真価は「低レイテンシ」「予測可能な性能」「低メモリ消費」の3点です。

FAQ

Q1. C++ から Rust に移行すべき? A. 新規コードはRustが有力です。既存の大規模C++コードベースを全部書き換える必要はなく、FFIでモジュール単位で置き換える戦略が現実的です。

Q2. Go と比べて何が違う? A. Go はシンプルさと開発速度重視、Rust は安全性と性能重視。WebバックエンドはGo、OS・組込・高性能サービスはRustが多いです。

Q3. 学習期間はどのくらい? A. プログラミング経験者で、borrow checker に慣れるまで1〜3ヶ月、中規模アプリを書けるまで半年が目安です。

Q4. AI / 機械学習には使える? A. 推論サイドでは Burn、Candle、tch-rs など成熟しつつあります。訓練はまだ Python (PyTorch) が主流。

Q5. WebAssembly にはRustが必須? A. 必須ではありませんが、事実上の第一選択です。バイナリサイズ、性能、エコシステムで優位。

まとめ (追加)

2025〜2026年にかけて、Rust は「一部のシステム系言語マニア向け」から「安全性と性能が両方必要な場面のデフォルト」へと位置づけが変わりました。Webバックエンド、データエンジニアリング、組込、ブロックチェーン、機械学習推論、エッジコンピューティング、WebAssembly、OSカーネルと、活用領域は広がり続けています。学習曲線は依然として急ですが、一度身につければ長期的に報われる言語です。

補足: プロジェクト構成のベストプラクティス

推奨ディレクトリ構成

my-service:

• Cargo.toml (workspace definition)
• crates/
  • api/ (HTTP layer - axum)
  • core/ (domain logic - pure Rust)
  • storage/ (DB adapters - sqlx)
  • worker/ (background jobs)
• migrations/ (sqlx migrations)
• tests/ (integration tests)
• xtask/ (custom build tasks)

ワークスペースに分割することで、コンパイルキャッシュが効きやすくなり、依存の方向が明確になります。

Cargo.toml のチューニング例

[workspace]
members = ["crates/*", "xtask"]

[workspace.package]
edition = "2024"
rust-version = "1.83"

[workspace.dependencies]
tokio = { version = "1", features = ["full"] }
serde = { version = "1", features = ["derive"] }
thiserror = "2"
anyhow = "1"
tracing = "0.1"

[profile.release]
lto = "thin"
codegen-units = 1
strip = true
panic = "abort"

可観測性の標準構成

use tracing::{info, instrument};
use tracing_subscriber::{EnvFilter, fmt};

fn init_telemetry() {
    fmt()
        .with_env_filter(EnvFilter::from_default_env())
        .with_target(false)
        .json()
        .init();
}

#[instrument(skip(db))]
async fn handle_request(user_id: u64, db: &Database) -> Result<Response, AppError> {
    info!("processing request");
    let user = db.fetch_user(user_id).await?;
    Ok(Response::new(user))
}

tracing + tracing-subscriber + opentelemetry-otlp の組み合わせが事実上の標準で、スパン・ログ・メトリクスを一元的に扱えます。

テスト戦略

#[cfg(test)]
mod tests {
    use super::*;

    #[tokio::test]
    async fn fetches_existing_user() {
        let db = Database::in_memory();
        db.insert_user(User { id: 1, name: "Alice".into() }).await.unwrap();

        let user = db.fetch_user(1).await.unwrap();
        assert_eq!(user.name, "Alice");
    }

    #[tokio::test]
    async fn returns_error_for_missing_user() {
        let db = Database::in_memory();
        let err = db.fetch_user(999).await.unwrap_err();
        assert!(matches!(err, AppError::NotFound));
    }
}

ユニットテストに加え、cargo nextest run で並列実行、proptest でプロパティテスト、criterion でベンチを取ると品質を継続的に担保できます。Rustはテストファーストが書きやすい言語であり、エンタープライズ採用が進んだ理由の一つでもあります。

参考リソース

• Rust 公式サイト
• The Rust Programming Language Book
• Rust 公式ブログ
• Rust Foundation