#Rust Introduction for DevOps

1# Install Rust using rustup
2curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh
3
4# Reload shell
5source ~/.cargo/env
6
7# Verify installation
8rustc --version
9cargo --version
10
11# Update Rust
12rustup update

fn main() {
    println!("Hello, DevOps!");
}

1# Compile and run
2rustc main.rs
3./main
4
5# Or use Cargo (recommended)
6cargo new my-project
7cd my-project
8cargo run

1fn main() {
2    // Immutable by default
3    let server_name = "web-server-01";
4    let port: u16 = 8080;
5    let is_healthy = true;
6    
7    // Mutable variable
8    let mut count = 0;
9    count += 1;
10    
11    // Vectors (dynamic arrays)
12    let servers = vec!["web-01", "web-02", "web-03"];
13    
14    // HashMap
15    use std::collections::HashMap;
16    let mut config = HashMap::new();
17    config.insert("name", "web-server-01");
18    config.insert("ip", "10.0.1.100");
19    
20    println!("Server: {}, Port: {}", server_name, port);
21}

1struct Server {
2    name: String,
3    ip: String,
4    port: u16,
5    is_healthy: bool,
6}
7
8impl Server {
9    fn new(name: &str, ip: &str, port: u16) -> Self {
10        Server {
11            name: name.to_string(),
12            ip: ip.to_string(),
13            port,
14            is_healthy: true,
15        }
16    }
17    
18    fn check_health(&self) -> bool {
19        println!("Checking health of {}...", self.name);
20        self.is_healthy
21    }
22    
23    fn address(&self) -> String {
24        format!("{}:{}", self.ip, self.port)
25    }
26}
27
28fn main() {
29    let server = Server::new("web-01", "10.0.1.100", 8080);
30    println!("Address: {}", server.address());
31    println!("Healthy: {}", server.check_health());
32}

1use std::fs;
2use std::io;
3
4fn read_config(path: &str) -> Result<String, io::Error> {
5    fs::read_to_string(path)
6}
7
8fn main() {
9    match read_config("/etc/myapp/config.yaml") {
10        Ok(content) => println!("Config: {}", content),
11        Err(e) => eprintln!("Error: {}", e),
12    }
13    
14    // Or use ? operator
15    // let content = read_config("config.yaml")?;
16}

# Cargo.toml
[dependencies]
clap = { version = "4", features = ["derive"] }

1use clap::{Parser, Subcommand};
2
3#[derive(Parser)]
4#[command(name = "devops-cli")]
5#[command(about = "DevOps automation tool", long_about = None)]
6struct Cli {
7    #[command(subcommand)]
8    command: Commands,
9}
10
11#[derive(Subcommand)]
12enum Commands {
13    /// List servers
14    List {
15        #[arg(short, long, default_value = "all")]
16        environment: String,
17    },
18    /// Check server health
19    Health {
20        /// Server name
21        name: String,
22    },
23}
24
25fn main() {
26    let cli = Cli::parse();
27    
28    match cli.command {
29        Commands::List { environment } => {
30            println!("Listing servers for: {}", environment);
31        }
32        Commands::Health { name } => {
33            println!("Checking health of: {}", name);
34        }
35    }
36}

1# ripgrep - faster grep
2cargo install ripgrep
3rg "error" /var/log/
4
5# fd - faster find
6cargo install fd-find
7fd "*.yaml" /etc/
8
9# bat - better cat
10cargo install bat
11bat /etc/nginx/nginx.conf
12
13# bottom - system monitor
14cargo install bottom
15btm