Tutorial Membangun CLI Tool Modern dengan Rust, Clap v5, dan Tokio

Command-line interface (CLI) tetap menjadi fondasi penting dalam ekosistem developer modern. Dari automation script hingga deployment tools, CLI memberikan kontrol presisi yang tidak bisa ditandingi oleh graphical user interface. Di tahun 2026, Rust semakin dominan sebagai bahasa pilihan untuk membangun CLI tools berkat performa native, binary tunggal, dan safety guarantees yang solid. Artikel ini akan membimbingmu membangun CLI tool modern menggunakan Rust dengan Clap v5 untuk argument parsing dan Tokio untuk operasi asynchronous.

Mengapa Rust untuk CLI Tool?

Rust menawarkan beberapa keunggulan unik untuk pengembangan CLI. Pertama, binary yang dihasilkan bersifat self-contained: satu file executable tanpa runtime dependency. Kedua, borrow checker Rust mencegah memory safety bugs seperti use-after-free atau data races sejak compile time. Ketiga, ekosistem crate Rust untuk CLI sudah sangat matang. TechBytes menyebutkan bahwa kombinasi Clap dan Tokio adalah gold standard untuk CLI development di 2026.

Dibandingkan dengan Go atau Python, Rust menghasilkan binary yang lebih kecil dan lebih cepat. Tools seperti ripgrep, fd, dan delta menunjukkan bahwa Rust CLI bisa bersaing langsung dengan implementasi C dalam hal kecepatan, sambil menawarkan developer experience yang jauh lebih aman.

Persiapan Environment

Sebelum mulai, pastikan sistemmu sudah terpasang Rust toolchain versi 1.95.0 atau lebih baru. Install melalui rustup.rs. Tambahkan komponen rust-analyzer dan clippy untuk pengalaman development yang optimal. Pastikan juga cargo tersedia di PATH dengan menjalankan cargo --version.

Untuk IDE, VS Code dengan ekstensi rust-analyzer adalah kombinasi paling populer. Neovim dengan LSP juga menjadi pilihan banyak developer Rust berpengalaman. Pastikan formatter rustfmt aktif agar kode selalu konsisten.

Langkah 1: Inisialisasi Proyek dengan Cargo

Buat proyek baru menggunakan Cargo. Buka terminal dan jalankan perintah berikut:

cargo new rusttool --bin
cd rusttool

Perintah ini akan membuat struktur direktori standar dengan src/main.rs dan Cargo.toml. Buka Cargo.toml dan tambahkan dependency yang dibutuhkan:

[dependencies]
clap = { version = \"4.5\", features = [\"derive\", \"env\"] }
tokio = { version = \"1.40\", features = [\"full\"] }
reqwest = { version = \"0.12\", features = [\"json\"] }
anyhow = \"1.0\"
serde = { version = \"1.0\", features = [\"derive\"] }
colored = \"2.0\"

Crate colored akan membantu kita memberikan output berwarna di terminal. Jalankan cargo check untuk memastikan dependency terunduh tanpa error.

Langkah 2: Parsing Argumen dengan Clap v5

Clap dengan fitur derive memungkinkan kita mendefinisikan CLI interface menggunakan struct dan enum. Buka src/main.rs dan ganti isinya dengan kode berikut:

use clap::Parser;
use colored::Colorize;

#[derive(Parser)]
#[command(name = \"rusttool\", version = \"1.0.0\", about = \"CLI tool modern dengan Rust\")]
struct Cli {
    #[arg(short, long, default_value_t = false)]
    verbose: bool,
    #[arg(short, long, value_name = \"FILE\")]
    config: Option<std::path::PathBuf>,
    #[command(subcommand)]
    command: Commands,
}

#[derive(clap::Subcommand)]
enum Commands {
    Sync { #[arg(short, long)] force: bool },
    Fetch { url: String },
}

Pola ini menghasilkan help text otomatis, validasi tipe data, dan shell completions. Clap akan menolak input yang tidak valid sebelum kode business logic dijalankan. Fitur env memungkinkan override melalui environment variable.

Langkah 3: Menambahkan Subcommand

Subcommand membuat CLI lebih discoverable dan terstruktur. Tambahkan implementasi untuk masing-masing subcommand di dalam fungsi main:

#[tokio::main]
async fn main() -> anyhow::Result<()> {
    let cli = Cli::parse();
    if cli.verbose {
        println!(\"{}", \"Verbose mode enabled\".yellow());
    }
    match cli.command {
        Commands::Sync { force } => {
            println!(\"Syncing data... force={}\", force);
        }
        Commands::Fetch { url } => {
            println!(\"Fetching from: {}\", url);
        }
    }
    Ok(())
}

Macro #[tokio::main] mengubah fungsi main menjadi async runtime secara otomatis. Attribute #[arg(short, long)] menghasilkan flag -f dan --force tanpa boilerplate tambahan.

Langkah 4: Operasi Async dengan Tokio

CLI tools modern sering melakukan I/O atau network requests. Dengan Tokio, kita bisa menangani operasi concurrent tanpa blocking thread utama. Modifikasi subcommand Fetch untuk melakukan HTTP request:

Commands::Fetch { url } => {
    let client = reqwest::Client::new();
    let res = client.get(&url).send().await?;
    let status = res.status();
    let body = res.text().await?;
    println!(\"Status: {} | Response length: {} bytes\", status, body.len());
}

Operator ? bekerja sama dengan anyhow::Result untuk mengubah error dari library eksternal menjadi error context yang readable oleh user. Pola ini menghindari pyramid of doom yang umum di callback-based async code.

Langkah 5: Error Handling yang Proper

Error handling adalah aspek kritis dalam CLI tools. User harus mendapatkan pesan yang jelas ketika sesuatu gagal. Gunakan thiserror untuk library errors dan anyhow untuk application-level errors. Contoh implementasi:

use anyhow::Context;

let config_path = cli.config.as_ref()
    .context(\"Config file required for this operation\")?;
let content = std::fs::read_to_string(config_path)
    .with_context(|| format!(\"Failed to read config: {:?}\", config_path))?;

Method with_context menambahkan informasi tambahan ke error chain tanpa kehilangan root cause. Ini sangat berguna saat debugging di production.

Langkah 6: Build dan Distribusi

Setelah development selesai, build binary untuk production:

cargo build --release

Binary hasil compile berada di target/release/rusttool. Untuk distribusi cross-platform, gunakan cross atau GitHub Actions. Binary tunggal ini bisa langsung di-copy ke server tanpa dependency manager atau runtime tambahan.

Untuk mengoptimalkan ukuran binary, tambahkan konfigurasi berikut di Cargo.toml:

[profile.release]
strip = true
lto = true
opt-level = \"z\"

Kesimpulan

Membangun CLI tool dengan Rust, Clap, dan Tokio memberikan fondasi yang kuat untuk tools yang aman, cepat, dan maintainable. Kombinasi derive macros, async runtime, dan error handling ergonomis membuat Rust menjadi pilihan utama untuk CLI development di 2026. Untuk referensi lebih lanjut, kunjungi dokumentasi Clap dan Cargo Book.