Rust para Linuxeros

Llevas años escribiendo scripts en Bash. Te sacan del paso, pero cuando crecen, se vuelven una pesadilla de mantener. Has mirado Python, pero no te termina de convencer para según qué cosas — dependencias, rendimiento, ejecutables que funcionen en cualquier máquina sin instalar nada. Bienvenido a Rust.

Este tutorial no va de ownership, lifetimes ni teoría de tipos. Esto va de construir herramientas que funcionan, que son rápidas como el rayo, que se compilan en un solo binario y que puedes distribuir sin dependencias. Si eres sysadmin, self-hoster o simplemente un linuxero al que le gusta tener control sobre sus herramientas, estás en el sitio correcto.

Al terminar este tutorial, serás capaz de:

• Escribir scripts en Rust que reemplacen a Bash cuando este se queda corto
• Construir CLI tools profesionales con colores, argumentos y autocompletado
• Crear servicios HTTP ligeros para tu infraestructura self-hosted
• Automatizar tareas con la fiabilidad de un lenguaje compilado
• Distribuir tus herramientas como un solo binario estático

Y todo ello, programando en español, en Linux, y sin rodeos.

Por qué Rust para un linuxero

Antes de instalar nada, entiende por qué merece la pena.

Situación	Bash	Python	Rust
Script de 10 líneas	✅	✅	❌ (excesivo)
Script de 200 líneas con lógica compleja	❌	✅	✅
CLI tool con argumentos, colores, subcomandos	❌	✅	✅✅
Servicio HTTP que corre 24/7	❌	✅	✅✅
Procesar 1GB de logs	❌	🟡	✅✅
Ejecutable único, sin dependencias	✅	❌	✅✅
Rendimiento máximo	🟡	❌	✅✅
Seguridad de memoria garantizada	❌	❌	✅

Rust no es para todo, pero donde brilla, arrasa. Y este tutorial se centra exactamente en ese punto: las tareas donde Bash se queda corto, Python va justo, y Rust encaja como un guante.

Instalación de la toolchain

La forma oficial y recomendada es con rustup. Nada de repositorios de la distribución — Rust se mueve demasiado rápido para eso.

# Descarga e instala rustup
curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh

El script te preguntará:

1. 1) Proceed with installation (default) — pulsa Enter
2. Se instalará el toolchain estable (stable)
3. Añadirá ~/.cargo/bin a tu PATH (modifica ~/.bashrc o ~/.zshrc)

Si prefieres no usar curl | sh, puedes descargar el script, revisarlo y ejecutarlo:

curl -O https://static.rust-lang.org/rustup/dist/x86_64-unknown-linux-gnu/rustup-init
less rustup-init  # revísalo si eres paranoico
chmod +x rustup-init
./rustup-init

Verificación

rustc --version
# rustc 1.85.0 (o similar)

cargo --version
# cargo 1.85.0 (o similar)

rustup show
# Muestra el toolchain activo y sus componentes

Componentes útiles

Además del compilador, instala estos componentes desde ya:

rustup component add rust-analyzer  # LSP para tu editor
rustup component add clippy         # Linter bestia
rustup component add rustfmt        # Formateador oficial

Si usas Neovim (tutorial en atareao.es), VS Code o cualquier editor con LSP, rust-analyzer te dará autocompletado, diagnósticos en tiempo real y navegación de código.

Tu primer proyecto: «crustaceo-cli»

Vamos a crear el proyecto que usaremos como base para los siguientes capítulos:

cargo new crustaceo-cli
cd crustaceo-cli

Esto crea:

• Cargo.toml — el archivo de configuración del proyecto (como package.json en Node o pyproject.toml en Python)
• src/main.rs — el punto de entrada

Echa un vistazo a Cargo.toml:

[package]
name = "crustaceo-cli"
version = "0.1.0"
edition = "2024"

La edition indica qué versión del lenguaje usas. Desde Rust 1.85, la edición por defecto es 2024.

Ahora src/main.rs:

fn main() {
    println!("🦀 Hola, soy el crustáceo!");
}

Compila y ejecuta:

cargo run
#   Compiling crustaceo-cli v0.1.0
#    Finished `dev` profile [unoptimized + debuginfo]
#     Running `target/debug/crustaceo-cli`
# 🦀 Hola, soy el crustáceo!

Felicidades. Acabas de compilar tu primer programa en Rust. 💪

El flujo de trabajo en Rust

Comando	Qué hace
cargo new <nombre>	Crea un nuevo proyecto
cargo build	Compila en modo debug (rápido)
cargo build --release	Compila en modo release (optimizado, lento)
cargo run	Compila y ejecuta
cargo check	Solo comprueba que compila (sin generar binario)
cargo test	Ejecuta los tests
cargo clippy	Ejecuta el linter
cargo fmt	Formatea el código

Consejo: Usa cargo check constantemente mientras desarrollas. Es más rápido que cargo build y te da feedback instantáneo de si tu código compila.

El binario resultado

El ejecutable compilado está en target/debug/crustaceo-cli (o target/release/crustaceo-cli si usas --release).

Puedes copiarlo a cualquier máquina Linux sin necesidad de instalar Rust:

# Desde tu máquina de desarrollo
cp target/release/crustaceo-cli ~/bin/

# En cualquier otra máquina Linux (misma arquitectura)
scp target/release/crustaceo-cli usuario@server:~/bin/
./crustaceo-cli
# 🦀 Hola, soy el crustáceo!

Esto ya es más de lo que puedes hacer con un script de Python o Node. Un solo binario, cero dependencias.

Verificación

# 1. Rust instalado correctamente
rustc --version  # → rustc 1.85.X
cargo --version  # → cargo 1.85.X

# 2. Proyecto creado y compila
cd ~/crustaceo-cli && cargo build
./target/debug/crustaceo-cli  # → 🦀 Hola, soy el crustáceo!

# 3. Release build funciona
cargo build --release
./target/release/crustaceo-cli  # → 🦀 Hola, soy el crustáceo!

Conclusión

Escribir scripts en Bash siempre será útil para automatizar tareas sencillas del día a día, pero cuando tus necesidades escalan, tus herramientas también deben hacerlo. Rust no viene a sustituir por completo tu flujo de trabajo en la terminal, sino a convertirse en ese aliado estratégico para cuando necesitas la máxima velocidad, estabilidad a prueba de bombas y una distribución sin dolores de cabeza.

Ya tienes la toolchain configurada y funcionando en tu máquina Linux, y has comprobado lo sencillo que es compilar y dar vida a un proyecto desde cero. La base está lista.

En el capítulo 01, dejaremos atrás los mensajes de bienvenida y nos meteremos de lleno en harina: vamos a construir un script real que procese argumentos de la línea de comandos, interactúe con la entrada y salida estándar, y gestione errores de forma profesional. Prepárate, porque es aquí donde vas a empezar a ver el verdadero potencial de Rust en tu ecosistema.

---

Más información,

• Tutorial de Rust oficial (The Book) — para cuando quieras profundizar
• Rust by Example — ejemplos prácticos
• Tutorial Scripts en Bash en atareao.es — el punto de partida para saber cuándo saltar a Rust
• Instalación de herramientas en Linux en atareao.es — gestión de binarios y PATH