Rust for Backend and CLI

Rust

J"Rust is like C++ went to therapy, learned about memory safety, and came back as the responsible adult in the programming world—minus the midlife crisis!"

Why Use Rust for Backend and CLI?

Rust isn’t just for system programming or high-performance applications; it also shines in backend development and command-line interfaces (CLI)!

• Blazing Fast – Rust runs at near-native speed, making it perfect for backend servers and CLI tools.
• Memory Safety – No more segmentation faults or memory leaks (looking at you, C++ 👀).
• Concurrency Champion – Rust’s async features and thread safety make multi-threading a breeze.
• Cross-Platform – Write once, run anywhere—Linux, macOS, Windows, and even embedded devices.

Setting Up Rust for Backend Development

Let’s build a simple web server using Rust and Axum (a lightweight and ergonomic web framework).

Create a New Rust Project

cargo new rust_backend_demo
cd rust_backend_demo

Add dependencies in Cargo.toml:

[dependencies]
axum = "0.6"
tokio = { version = "1", features = ["full"] }

Write a Simple Web Server

Edit src/main.rs:

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

#[tokio::main]
async fn main() {
    let app = Router::new().route("/", get(|| async { "Hello, Rust Backend!" }));

    let addr = SocketAddr::from(([127, 0, 0, 1], 3000));
    println!("Server running at http://{}", addr);

    axum::Server::bind(&addr)
        .serve(app.into_make_service())
        .await
        .unwrap();
}

Run the Server

cargo run

Open your browser and visit http://127.0.0.1:3000—Boom! Your Rust-powered web backend is live!

Building a Command-Line Tool (CLI)

Rust is awesome for CLI tools! Let’s create a simple CLI program using clap (a powerful CLI argument parser).

Add Dependencies

Modify Cargo.toml:

[dependencies]
clap = { version = "4", features = ["derive"] }

Write the CLI Tool

Edit src/main.rs:

use clap::{Arg, Command};

fn main() {
    let matches = Command::new("rust_cli_demo")
        .version("1.0")
        .author("Rustacean")
        .about("A simple Rust CLI tool")
        .arg(Arg::new("name")
            .short('n')
            .long("name")
            .value_name("NAME")
            .help("Your name")
            .required(true))
        .get_matches();

    if let Some(name) = matches.get_one::<String>("name") {
        println!("Hello, {}! Welcome to Rust CLI", name);
    }
}

Run the CLI Tool

cargo run -- --name Rustacean

Output:

Hello, Rustacean! Welcome to Rust CLI 

 Your first Rust CLI tool is ready!

Conclusion

Rust is blazing fast, memory-safe, and cross-platform, making it an excellent choice for backend services and CLI tools.

So, whether you're building web APIs or automating tasks, Rust has got your back! 

Ready to build your own Rust-powered backend or CLI tool? Let’s go!