Rust
Tutorial Rust: Instalación del entorno
Aprende a instalar Rust con rustup, configurar VS Code con rust-analyzer y usar herramientas esenciales como Cargo y Clippy para programar en Rust.
Aprende Rust y certifícateRustup y toolchain
Rustup es el instalador oficial y gestor de versiones para el lenguaje de programación Rust. Esta herramienta nos permite instalar, actualizar y gestionar diferentes versiones del compilador de Rust y sus componentes asociados. Antes de empezar a programar en Rust, necesitamos configurar nuestro entorno de desarrollo, y el primer paso es instalar Rustup.
Instalación de Rustup
El proceso de instalación varía ligeramente según el sistema operativo que utilices:
En Windows
Visita la página oficial de Rust en https://www.rust-lang.org/tools/install
Descarga el instalador de Rustup para Windows (rustup-init.exe)
Ejecuta el archivo descargado. Aparecerá una ventana de consola con opciones de instalación:
Current installation options:
default host triple: x86_64-pc-windows-msvc
default toolchain: stable (default)
profile: default
modify PATH variable: yes
1) Proceed with installation (default)
2) Customize installation
3) Cancel installation
Selecciona la opción 1 para una instalación estándar.
Es posible que necesites instalar las Visual C++ Build Tools si no las tienes. El instalador te guiará en este proceso si es necesario.
En macOS y Linux
- Abre una terminal y ejecuta el siguiente comando:
curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh
- Selecciona la opción de instalación predeterminada cuando se te solicite:
Current installation options:
default host triple: x86_64-apple-darwin
default toolchain: stable (default)
profile: default
modify PATH variable: yes
1) Proceed with installation (default)
2) Customize installation
3) Cancel installation
- Una vez completada la instalación, necesitarás reiniciar la terminal o ejecutar el siguiente comando para actualizar las variables de entorno:
source $HOME/.cargo/env
Verificación de la instalación
Para comprobar que Rust se ha instalado correctamente, abre una nueva terminal y ejecuta:
rustc --version
Deberías ver algo similar a:
rustc 1.75.0 (82e1608df 2023-12-21)
También puedes verificar la versión de Rustup:
rustup --version
Entendiendo el concepto de toolchain
Una toolchain en Rust es un conjunto completo de herramientas necesarias para compilar código Rust. Incluye:
- rustc: El compilador de Rust
- cargo: El gestor de paquetes y sistema de construcción
- rustfmt: Formateador de código
- clippy: Analizador de código (linter)
- rust-std: La biblioteca estándar de Rust
Rustup nos permite gestionar múltiples toolchains, lo que es útil para:
- Probar diferentes versiones de Rust
- Trabajar con características experimentales
- Compilar para diferentes plataformas
Canales de distribución (release channels)
Rust se distribuye en tres canales principales:
- Stable: Versión estable recomendada para uso general
- Beta: Próxima versión estable en fase de pruebas
- Nightly: Versión de desarrollo con las últimas características (algunas experimentales)
Por defecto, Rustup instala el canal stable, que es el recomendado para comenzar.
Comandos básicos de Rustup
Ver las toolchains instaladas
rustup toolchain list
Instalar una toolchain específica
rustup install nightly
Cambiar la toolchain predeterminada
rustup default nightly
Usar una toolchain específica para un comando
rustup run nightly rustc --version
Actualizar todas las toolchains instaladas
rustup update
Instalar componentes adicionales
rustup component add rustfmt clippy
Compilación cruzada (cross-compilation)
Una de las ventajas de Rustup es la facilidad para configurar la compilación cruzada, permitiéndonos compilar código para diferentes plataformas:
- Listar los targets disponibles:
rustup target list
- Instalar un target específico:
rustup target add aarch64-apple-ios
- Compilar para ese target:
cargo build --target aarch64-apple-ios
Perfiles de instalación
Rustup ofrece diferentes perfiles que determinan qué componentes se instalan:
- minimal: Solo el compilador y cargo
- default: Incluye rustfmt y clippy
- complete: Todos los componentes disponibles
Para cambiar el perfil:
rustup set profile complete
Solución de problemas comunes
Errores de permisos en Linux/macOS
Si encuentras errores de permisos, evita usar sudo
con rustup. En su lugar, sigue las instrucciones para instalar Rust en tu directorio personal.
Problemas con el PATH
Si los comandos de Rust no son reconocidos después de la instalación, asegúrate de que la ruta ~/.cargo/bin
(en Linux/macOS) o %USERPROFILE%\.cargo\bin
(en Windows) esté en tu variable de entorno PATH.
Desinstalar Rust
Si necesitas desinstalar Rust completamente:
rustup self uninstall
Con Rustup instalado y configurado correctamente, tendrás acceso a todas las herramientas necesarias para comenzar a desarrollar en Rust. En las siguientes secciones, configuraremos un entorno de desarrollo integrado (IDE) y exploraremos las herramientas que vienen incluidas con Rust.
IDE Visual Studio Code y rust-analyzer
Un entorno de desarrollo integrado (IDE) adecuado mejora significativamente la experiencia de programación en Rust. Visual Studio Code (VS Code) se ha convertido en una de las opciones más populares gracias a su ligereza, extensibilidad y excelente soporte para Rust mediante la extensión rust-analyzer.
Instalación de Visual Studio Code
Antes de configurar nuestro entorno para Rust, necesitamos instalar VS Code:
Visita la página oficial de VS Code: https://code.visualstudio.com/
Descarga la versión adecuada para tu sistema operativo (Windows, macOS o Linux)
Sigue las instrucciones del instalador:
- En Windows: Ejecuta el archivo .exe descargado y sigue el asistente
- En macOS: Abre el archivo .dmg y arrastra VS Code a la carpeta Aplicaciones
- En Linux: Utiliza el gestor de paquetes de tu distribución o el paquete .deb/.rpm descargado
Configuración de rust-analyzer
Una vez instalado VS Code, necesitamos añadir la extensión rust-analyzer, que proporciona funcionalidades esenciales como:
- Autocompletado inteligente
- Navegación de código
- Diagnósticos en tiempo real
- Refactorización de código
- Vista de documentación integrada
Para instalar rust-analyzer:
Abre VS Code
Accede al panel de extensiones haciendo clic en el icono de extensiones en la barra lateral izquierda (o presiona
Ctrl+Shift+X
/Cmd+Shift+X
en macOS)Busca "rust-analyzer" en el cuadro de búsqueda
Haz clic en el botón "Instalar" junto a la extensión rust-analyzer
Configuración adicional recomendada
Para mejorar tu experiencia de desarrollo en Rust, te recomendamos algunas configuraciones adicionales:
Abre la configuración de VS Code (presiona
Ctrl+,
oCmd+,
en macOS)Busca "rust" en el cuadro de búsqueda para ver todas las opciones relacionadas con Rust
Considera activar estas opciones útiles:
{
"editor.formatOnSave": true,
"rust-analyzer.checkOnSave.command": "clippy",
"rust-analyzer.inlayHints.enable": true
}
Estas configuraciones permiten:
- Formatear automáticamente tu código al guardar
- Usar Clippy para análisis de código más avanzado
- Mostrar pistas en línea sobre tipos y parámetros
Creando y abriendo un proyecto Rust
Para probar que todo funciona correctamente:
Abre una terminal (puedes usar la terminal integrada de VS Code con
Ctrl+
oCmd+
en macOS)Crea un nuevo proyecto Rust:
cargo new mi_primer_proyecto
- Abre la carpeta del proyecto en VS Code:
code mi_primer_proyecto
- Explora la estructura del proyecto:
Cargo.toml
: Archivo de configuración del proyectosrc/main.rs
: Archivo principal con código fuente
- Abre
src/main.rs
y observa cómo rust-analyzer proporciona información sobre el código:
fn main() {
println!("¡Hola, Rust!");
}
Funcionalidades clave de rust-analyzer
Ahora que tienes configurado tu entorno, veamos algunas de las funcionalidades más útiles que ofrece rust-analyzer:
Autocompletado: Escribe parte de una función o tipo y presiona
Ctrl+Space
para ver sugerenciasInformación sobre tipos: Coloca el cursor sobre una variable para ver su tipo
Ir a definición: Haz clic derecho en un símbolo y selecciona "Ir a definición" o presiona
F12
Refactorización: Coloca el cursor sobre código y presiona
Ctrl+.
oCmd+.
para ver acciones disponiblesEjecución y depuración: Haz clic en el botón "Run" sobre la función
main()
o configura tareas de depuración
Depuración de código Rust
VS Code permite depurar código Rust con la extensión adecuada:
Instala la extensión "CodeLLDB" desde el panel de extensiones
Crea un archivo de configuración de depuración:
- Haz clic en el icono de depuración en la barra lateral
- Selecciona "create a launch.json file"
- Elige "LLDB" como entorno
- Configura el archivo
launch.json
generado:
{
"version": "0.2.0",
"configurations": [
{
"type": "lldb",
"request": "launch",
"name": "Debug executable",
"cargo": {
"args": ["build", "--bin=mi_primer_proyecto"],
"filter": {
"name": "mi_primer_proyecto",
"kind": "bin"
}
},
"args": [],
"cwd": "${workspaceFolder}"
}
]
}
Establece puntos de interrupción haciendo clic en el margen izquierdo junto al número de línea
Inicia la depuración con F5
Alternativas a VS Code
Aunque VS Code con rust-analyzer es la configuración más popular, existen otras alternativas:
IntelliJ IDEA con el plugin Rust: Ofrece una experiencia más integrada similar a otros IDEs de JetBrains
CLion: IDE específico para lenguajes como C, C++ y Rust, con excelente soporte para depuración
Vim/Neovim con rust-analyzer: Para desarrolladores que prefieren editores basados en terminal
Sublime Text con LSP: Configuración más ligera pero con menos funcionalidades integradas
Solución de problemas comunes
Si encuentras problemas con rust-analyzer:
Extensión no funciona: Verifica que Rust esté correctamente instalado ejecutando
rustc --version
en terminalAutocompletado lento: Ajusta la configuración de rust-analyzer para limitar el análisis en proyectos grandes:
{
"rust-analyzer.cargo.loadOutDirsFromCheck": false,
"rust-analyzer.procMacro.enable": false
}
Errores de análisis: Actualiza rust-analyzer a la última versión y ejecuta
cargo clean
en tu proyectoProblemas con crates específicos: Algunos crates muy complejos pueden causar problemas. Considera excluirlos del análisis:
{
"rust-analyzer.cargo.features": ["--all-features"],
"rust-analyzer.diagnostics.disabled": ["unresolved-proc-macro"]
}
Con VS Code y rust-analyzer correctamente configurados, dispondrás de un entorno de desarrollo potente que te ayudará a escribir código Rust de forma más eficiente, con menos errores y siguiendo las mejores prácticas del lenguaje.
Herramientas integradas
Rust viene con un ecosistema de herramientas integradas que facilitan enormemente el desarrollo, la gestión de dependencias y el mantenimiento de código de calidad. Estas herramientas están disponibles automáticamente después de instalar Rust mediante rustup, y forman parte fundamental del flujo de trabajo diario de cualquier desarrollador Rust.
Cargo: el gestor de paquetes y sistema de construcción
Cargo es la herramienta central del ecosistema Rust. Funciona como gestor de paquetes, sistema de construcción y ejecutor de tareas. Cuando instalaste Rust, Cargo se instaló automáticamente junto con el compilador.
Para verificar que Cargo está correctamente instalado, ejecuta:
cargo --version
Creación de proyectos
Cargo simplifica la creación de nuevos proyectos con una estructura estandarizada:
cargo new mi_proyecto
Este comando genera una estructura de directorios como esta:
mi_proyecto/
├── Cargo.toml
└── src/
└── main.rs
El archivo Cargo.toml es el manifiesto del proyecto donde se definen metadatos, dependencias y configuraciones:
[package]
name = "mi_proyecto"
version = "0.1.0"
edition = "2021"
[dependencies]
Comandos básicos de Cargo
- Compilar un proyecto:
cargo build
- Ejecutar un programa:
cargo run
- Verificar que el código compila sin generar ejecutables:
cargo check
- Crear una versión optimizada para producción:
cargo build --release
- Actualizar dependencias:
cargo update
- Generar documentación del proyecto y sus dependencias:
cargo doc --open
Rustfmt: formateador de código automático
Rustfmt es una herramienta que formatea automáticamente el código Rust siguiendo el estilo oficial. Esto garantiza consistencia en todos los proyectos y evita debates sobre estilos de código.
Para instalar rustfmt (si no lo tienes ya):
rustup component add rustfmt
Uso básico de rustfmt
- Formatear un archivo específico:
rustfmt src/main.rs
- Formatear todo el proyecto:
cargo fmt
- Verificar si el código está correctamente formateado (útil en CI/CD):
cargo fmt -- --check
Ejemplo de código antes y después de aplicar rustfmt:
Antes:
fn suma(a:i32,b:i32)->i32{
let resultado=a+b;return resultado;
}
Después:
fn suma(a: i32, b: i32) -> i32 {
let resultado = a + b;
resultado
}
Clippy: el linter de Rust
Clippy es un analizador de código (linter) que detecta errores comunes, patrones ineficientes y sugiere mejoras siguiendo las mejores prácticas de Rust. Es como tener un mentor experimentado revisando tu código.
Para instalar Clippy:
rustup component add clippy
Uso básico de Clippy
- Analizar el proyecto en busca de problemas:
cargo clippy
- Aplicar sugerencias automáticamente (cuando sea posible):
cargo clippy --fix
Ejemplos de sugerencias de Clippy:
// Clippy detectará esto como ineficiente
if x.len() > 0 {
// hacer algo
}
// Y sugerirá usar esto en su lugar
if !x.is_empty() {
// hacer algo
}
Cargo Test: framework de pruebas integrado
Rust incluye un framework de pruebas integrado que facilita la creación y ejecución de pruebas unitarias, de integración y de documentación.
Creación de pruebas básicas
Las pruebas se escriben típicamente en el mismo archivo que el código que prueban:
fn suma(a: i32, b: i32) -> i32 {
a + b
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn test_suma() {
assert_eq!(suma(2, 3), 5);
assert_eq!(suma(-1, 1), 0);
}
}
Ejecución de pruebas
- Ejecutar todas las pruebas:
cargo test
- Ejecutar una prueba específica:
cargo test test_suma
- Mostrar la salida de las pruebas (normalmente oculta):
cargo test -- --nocapture
Cargo Bench: benchmarking de código
Para proyectos donde el rendimiento es crítico, Rust ofrece herramientas de benchmarking integradas (disponibles en el canal nightly).
Para habilitar benchmarking:
rustup install nightly
Ejemplo básico de benchmark:
#![feature(test)]
extern crate test;
fn fibonacci(n: u64) -> u64 {
match n {
0 => 0,
1 => 1,
_ => fibonacci(n - 1) + fibonacci(n - 2),
}
}
#[cfg(test)]
mod tests {
use super::*;
use test::Bencher;
#[bench]
fn bench_fibonacci_10(b: &mut Bencher) {
b.iter(|| fibonacci(10));
}
}
Para ejecutar los benchmarks:
cargo +nightly bench
Cargo Audit: análisis de seguridad
Cargo Audit es una herramienta que verifica las dependencias de tu proyecto en busca de vulnerabilidades conocidas.
Para instalar Cargo Audit:
cargo install cargo-audit
Para analizar las dependencias:
cargo audit
Ejemplo de salida:
Scanning Cargo.lock for vulnerabilities (advisory-db 310)
Vulnerability: time::parse can panic when given out-of-range values
Affected: time@0.1.42
Solution: Upgrade to >=0.1.43
Integración de herramientas en el flujo de trabajo
Para aprovechar al máximo estas herramientas, puedes integrarlas en tu flujo de trabajo diario:
- Antes de cada commit: ejecuta
cargo fmt
ycargo clippy
- Durante el desarrollo: usa
cargo check
para verificaciones rápidas - Antes de enviar código: ejecuta
cargo test
para asegurar que todo funciona - Periódicamente: ejecuta
cargo audit
para verificar problemas de seguridad
También puedes crear un alias para ejecutar varias herramientas a la vez:
# En .bashrc o .zshrc
alias rust-check="cargo fmt && cargo clippy && cargo test"
Git Hooks para automatización
Puedes configurar git hooks para ejecutar estas herramientas automáticamente antes de cada commit:
Crea un archivo .git/hooks/pre-commit
:
#!/bin/sh
cargo fmt -- --check
if [ $? -ne 0 ]; then
echo "Hay errores de formato. Ejecuta 'cargo fmt' antes de commit."
exit 1
fi
cargo clippy -- -D warnings
if [ $? -ne 0 ]; then
echo "Clippy encontró problemas. Corrígelos antes de commit."
exit 1
fi
cargo test
if [ $? -ne 0 ]; then
echo "Las pruebas fallaron. Corrígelas antes de commit."
exit 1
fi
exit 0
No olvides hacer el script ejecutable:
chmod +x .git/hooks/pre-commit
Con estas herramientas integradas en tu flujo de trabajo, estarás en el camino correcto para desarrollar código Rust de alta calidad, mantenible y seguro. A medida que te familiarices con el ecosistema, descubrirás más herramientas especializadas que pueden ayudarte en aspectos específicos del desarrollo.
Otras lecciones de Rust
Accede a todas las lecciones de Rust y aprende con ejemplos prácticos de código y ejercicios de programación con IDE web sin instalar nada.
Introducción A Rust
Introducción Y Entorno
Primer Programa
Introducción Y Entorno
Instalación Del Entorno
Introducción Y Entorno
Funciones
Sintaxis
Operadores
Sintaxis
Estructuras De Control Condicional
Sintaxis
Arrays Y Strings
Sintaxis
Manejo De Errores Panic
Sintaxis
Variables Y Tipos Básicos
Sintaxis
Estructuras De Control Iterativo
Sintaxis
Colecciones Estándar
Estructuras De Datos
Option Y Result
Estructuras De Datos
Pattern Matching
Estructuras De Datos
Estructuras (Structs)
Estructuras De Datos
Enumeraciones Enums
Estructuras De Datos
El Concepto De Ownership
Ownership
Lifetimes Básicos
Ownership
Slices Y Referencias Parciales
Ownership
References Y Borrowing
Ownership
Funciones Anónimas Closures
Abstracción
Traits De La Biblioteca Estándar
Abstracción
Traits
Abstracción
Generics
Abstracción
Channels Y Paso De Mensajes
Concurrencia
Memoria Compartida Segura
Concurrencia
Threads Y Sincronización Básica
Concurrencia
Introducción A Tokio
Asincronía
Fundamentos Asíncronos Y Futures
Asincronía
Async/await
Asincronía
Ejercicios de programación de Rust
Evalúa tus conocimientos de esta lección Instalación del entorno con nuestros retos de programación de tipo Test, Puzzle, Código y Proyecto con VSCode, guiados por IA.
En esta lección
Objetivos de aprendizaje de esta lección
- Entender qué es Rustup y cómo instalarlo en diferentes sistemas operativos.
- Configurar Visual Studio Code con la extensión rust-analyzer para un desarrollo eficiente en Rust.
- Conocer y utilizar las herramientas integradas de Rust: Cargo, Rustfmt, Clippy y el framework de pruebas.
- Aprender a gestionar toolchains, canales de distribución y perfiles de instalación con Rustup.
- Integrar herramientas de calidad y seguridad en el flujo de trabajo de desarrollo Rust.