Rust 생태계 2026 완벽 가이드 - Rust 1.85+ · tokio · axum · actix-web · sqlx · bevy · tauri · leptos · dioxus · embassy · cargo 심층 분석

use std::error::Error;

// 2024 에디션: async fn in trait, 매크로 불필요
pub trait UserRepo {
    async fn find_by_id(&self, id: u64) -> Result<Option<User>, Box<dyn Error + Send + Sync>>;
    async fn create(&self, user: NewUser) -> Result<User, Box<dyn Error + Send + Sync>>;
}

pub struct User { pub id: u64, pub email: String }
pub struct NewUser { pub email: String }

pub struct PgUserRepo { pool: sqlx::PgPool }

impl UserRepo for PgUserRepo {
    async fn find_by_id(&self, id: u64) -> Result<Option<User>, Box<dyn Error + Send + Sync>> {
        let row = sqlx::query_as::<_, (i64, String)>("SELECT id, email FROM users WHERE id = $1")
            .bind(id as i64)
            .fetch_optional(&self.pool)
            .await?;
        Ok(row.map(|(id, email)| User { id: id as u64, email }))
    }

    async fn create(&self, user: NewUser) -> Result<User, Box<dyn Error + Send + Sync>> {
        let row: (i64,) = sqlx::query_as("INSERT INTO users(email) VALUES ($1) RETURNING id")
            .bind(&user.email)
            .fetch_one(&self.pool)
            .await?;
        Ok(User { id: row.0 as u64, email: user.email })
    }
}

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

#[tokio::main(flavor = "multi_thread", worker_threads = 8)]
async fn main() {
    let (tx, mut rx) = mpsc::channel::<u64>(1024);

    // 프로듀서 100개
    for i in 0..100u64 {
        let tx = tx.clone();
        tokio::spawn(async move {
            for j in 0..1000u64 {
                let _ = tx.send(i * 1_000 + j).await;
                if j % 100 == 0 { sleep(Duration::from_micros(10)).await; }
            }
        });
    }
    drop(tx);

    // 컨슈머: 단일 태스크
    let mut count = 0u64;
    while let Some(_v) = rx.recv().await { count += 1; }
    println!("received: {count}");
}

use axum::{
    Router,
    extract::{Path, State},
    response::Json,
    routing::{get, post},
    http::StatusCode,
};
use serde::{Deserialize, Serialize};
use std::sync::Arc;
use sqlx::PgPool;

#[derive(Clone)]
struct AppState { pool: PgPool }

#[derive(Serialize)]
struct User { id: i64, email: String }

#[derive(Deserialize)]
struct CreateUser { email: String }

async fn get_user(
    State(state): State<Arc<AppState>>,
    Path(id): Path<i64>,
) -> Result<Json<User>, StatusCode> {
    let row = sqlx::query_as::<_, (i64, String)>(
        "SELECT id, email FROM users WHERE id = $1"
    )
    .bind(id)
    .fetch_optional(&state.pool)
    .await
    .map_err(|_| StatusCode::INTERNAL_SERVER_ERROR)?
    .ok_or(StatusCode::NOT_FOUND)?;

    Ok(Json(User { id: row.0, email: row.1 }))
}

async fn create_user(
    State(state): State<Arc<AppState>>,
    Json(payload): Json<CreateUser>,
) -> Result<(StatusCode, Json<User>), StatusCode> {
    let row: (i64,) = sqlx::query_as("INSERT INTO users(email) VALUES ($1) RETURNING id")
        .bind(&payload.email)
        .fetch_one(&state.pool)
        .await
        .map_err(|_| StatusCode::INTERNAL_SERVER_ERROR)?;
    Ok((StatusCode::CREATED, Json(User { id: row.0, email: payload.email })))
}

#[tokio::main]
async fn main() {
    let pool = PgPool::connect(&std::env::var("DATABASE_URL").unwrap()).await.unwrap();
    let state = Arc::new(AppState { pool });

    let app = Router::new()
        .route("/users/:id", get(get_user))
        .route("/users", post(create_user))
        .with_state(state);

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

use sqlx::PgPool;

#[derive(sqlx::FromRow)]
struct Order { id: i64, user_id: i64, total_cents: i64, status: String }

async fn list_user_orders(pool: &PgPool, user_id: i64) -> sqlx::Result<Vec<Order>> {
    // 매크로가 컴파일타임에 DB에 접속해 SELECT 컬럼 타입을 검사한다
    let orders = sqlx::query_as!(
        Order,
        r#"SELECT id, user_id, total_cents, status
           FROM orders
           WHERE user_id = $1
           ORDER BY id DESC
           LIMIT 100"#,
        user_id
    )
    .fetch_all(pool)
    .await?;
    Ok(orders)
}

// 라이브러리 측: thiserror로 명시적 에러 타입
use thiserror::Error;

#[derive(Debug, Error)]
pub enum BillingError {
    #[error("invoice not found: {0}")]
    NotFound(i64),

    #[error("database error")]
    Db(#[from] sqlx::Error),

    #[error("payment provider error: {0}")]
    Provider(String),
}

pub async fn charge(invoice_id: i64) -> Result<(), BillingError> {
    Err(BillingError::Provider("stripe timeout".into()))
}

// 애플리케이션 측: anyhow로 컨텍스트 누적
use anyhow::Context;

pub async fn process_batch(ids: &[i64]) -> anyhow::Result<()> {
    for &id in ids {
        charge(id).await
            .with_context(|| format!("failed to charge invoice {id}"))?;
    }
    Ok(())
}

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

#[instrument(skip(pool))]
async fn handle_request(pool: &sqlx::PgPool, user_id: i64) -> anyhow::Result<()> {
    info!(user_id, "processing request");
    let _row = sqlx::query("SELECT 1").fetch_one(pool).await?;
    Ok(())
}

#[tokio::main]
async fn main() {
    tracing_subscriber::registry()
        .with(EnvFilter::try_from_default_env().unwrap_or_else(|_| "info".into()))
        .with(fmt::layer().json())
        .init();

    info!("server starting");
}

use serde::{Deserialize, Serialize};

#[derive(Serialize, Deserialize, Debug)]
struct ApiResponse {
    #[serde(rename = "userId")]
    user_id: i64,

    #[serde(default)]
    tags: Vec<String>,

    #[serde(skip_serializing_if = "Option::is_none")]
    email: Option<String>,
}

fn parse_response(s: &str) -> serde_json::Result<ApiResponse> {
    serde_json::from_str(s)
}

// src-tauri/src/lib.rs
use tauri::command;

#[command]
async fn greet(name: String) -> Result<String, String> {
    Ok(format!("Hello, {name}!"))
}

#[command]
async fn read_file(path: String) -> Result<String, String> {
    tokio::fs::read_to_string(&path).await.map_err(|e| e.to_string())
}

#[cfg_attr(mobile, tauri::mobile_entry_point)]
pub fn run() {
    tauri::Builder::default()
        .plugin(tauri_plugin_shell::init())
        .invoke_handler(tauri::generate_handler![greet, read_file])
        .run(tauri::generate_context!())
        .expect("error while running tauri application");
}

use leptos::*;
use leptos::server_fn::ServerFn;
use serde::{Deserialize, Serialize};

#[derive(Serialize, Deserialize, Clone)]
pub struct Todo { pub id: i64, pub title: String, pub done: bool }

#[server]
pub async fn list_todos() -> Result<Vec<Todo>, ServerFnError> {
    Ok(vec![Todo { id: 1, title: "ship".into(), done: false }])
}

#[component]
pub fn TodoList() -> impl IntoView {
    let todos = create_resource(|| (), |_| async move { list_todos().await });

    view! {
        <Suspense fallback=move || view! { <p>"Loading..."</p> }>
            {move || todos.get().map(|res| match res {
                Ok(items) => view! {
                    <ul>{items.into_iter().map(|t| view!{ <li>{t.title}</li> }).collect_view()}</ul>
                }.into_view(),
                Err(_) => view! { <p>"error"</p> }.into_view(),
            })}
        </Suspense>
    }
}

use dioxus::prelude::*;

#[derive(Clone, PartialEq, Props)]
struct Todo { id: i64, title: String, done: bool }

fn TodoList(cx: Scope) -> Element {
    let todos = use_state(cx, || vec![Todo { id: 1, title: "ship".into(), done: false }]);

    cx.render(rsx! {
        ul {
            todos.iter().map(|t| rsx!{
                li { key: "{t.id}", "{t.title}" }
            })
        }
    })
}

use eframe::egui;

struct App { name: String, age: u32 }

impl eframe::App for App {
    fn update(&mut self, ctx: &egui::Context, _: &mut eframe::Frame) {
        egui::CentralPanel::default().show(ctx, |ui| {
            ui.heading("My egui Application");
            ui.horizontal(|ui| {
                ui.label("Your name: ");
                ui.text_edit_singleline(&mut self.name);
            });
            ui.add(egui::Slider::new(&mut self.age, 0..=120).text("age"));
            if ui.button("Increment").clicked() { self.age += 1; }
            ui.label(format!("Hello '{}', age {}", self.name, self.age));
        });
    }
}

fn main() -> eframe::Result<()> {
    let opts = eframe::NativeOptions::default();
    eframe::run_native(
        "demo",
        opts,
        Box::new(|_| Ok(Box::new(App { name: "Arthur".into(), age: 42 }))),
    )
}

use bevy::prelude::*;

#[derive(Component)]
struct Player { speed: f32 }

fn spawn_player(mut commands: Commands) {
    commands.spawn((
        Player { speed: 250.0 },
        Sprite::from_color(Color::srgb(0.2, 0.7, 1.0), Vec2::new(40.0, 40.0)),
        Transform::default(),
    ));
}

fn move_player(
    time: Res<Time>,
    keys: Res<ButtonInput<KeyCode>>,
    mut q: Query<(&Player, &mut Transform)>,
) {
    for (p, mut t) in &mut q {
        let mut dir = Vec3::ZERO;
        if keys.pressed(KeyCode::KeyW) { dir.y += 1.0; }
        if keys.pressed(KeyCode::KeyS) { dir.y -= 1.0; }
        if keys.pressed(KeyCode::KeyA) { dir.x -= 1.0; }
        if keys.pressed(KeyCode::KeyD) { dir.x += 1.0; }
        t.translation += dir.normalize_or_zero() * p.speed * time.delta_secs();
    }
}

fn main() {
    App::new()
        .add_plugins(DefaultPlugins)
        .add_systems(Startup, spawn_player)
        .add_systems(Update, move_player)
        .run();
}

#![no_std]
#![no_main]

use embassy_executor::Spawner;
use embassy_rp::gpio::{Level, Output};
use embassy_time::{Duration, Timer};
use {defmt_rtt as _, panic_probe as _};

#[embassy_executor::task]
async fn blink(mut led: Output<'static>) {
    loop {
        led.set_high();
        Timer::after(Duration::from_millis(500)).await;
        led.set_low();
        Timer::after(Duration::from_millis(500)).await;
    }
}

#[embassy_executor::main]
async fn main(spawner: Spawner) {
    let p = embassy_rp::init(Default::default());
    let led = Output::new(p.PIN_25, Level::Low);
    spawner.spawn(blink(led)).unwrap();
}

use clap::{Parser, Subcommand};

#[derive(Parser)]
#[command(name = "blogctl", version, about = "Blog management CLI")]
struct Cli {
    #[command(subcommand)]
    command: Cmd,
}

#[derive(Subcommand)]
enum Cmd {
    /// Create a new post
    New { title: String, #[arg(short, long)] draft: bool },
    /// Publish a post
    Publish { slug: String },
}

fn main() {
    let cli = Cli::parse();
    match cli.command {
        Cmd::New { title, draft } => println!("new post: {title} (draft={draft})"),
        Cmd::Publish { slug } => println!("publish {slug}"),
    }
}

# 워크스페이스 루트의 Cargo.toml
[workspace]
resolver = "3"
members = ["crates/api", "crates/domain", "crates/storage"]

[workspace.dependencies]
tokio = { version = "1.40", features = ["full"] }
sqlx = { version = "0.8", features = ["runtime-tokio-rustls", "postgres"] }
axum = "0.8"
serde = { version = "1", features = ["derive"] }
serde_json = "1"
thiserror = "1"
anyhow = "1"

[profile.release]
opt-level = 3
lto = "thin"
codegen-units = 1
strip = "symbols"

# 표준 CI 한 묶음
cargo fmt --all -- --check
cargo clippy --all-targets --all-features -- -D warnings
cargo nextest run --workspace --all-features
cargo deny check
cargo audit
cargo machete