353 lines
15 KiB
Markdown
353 lines
15 KiB
Markdown
|
╔════════════════════════════════════════════════════════════════════════════╗
|
||
|
|
║ ¿QUÉ ES https://sh.rustup.rs? - EL BOOTSTRAP COMPILER ║
|
||
|
|
╚════════════════════════════════════════════════════════════════════════════╝
|
||
|
|
|
||
|
|
ANTES DE ENTENDER sh.rustup.rs, NECESITAS SABER:
|
||
|
|
|
||
|
|
El Problema Fundamental del Bootstrap
|
||
|
|
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
|
||
|
|
|
||
|
|
Para compilar Rust necesitas:
|
||
|
|
├─ rustc (compilador)
|
||
|
|
└─ cargo (gestor de dependencias)
|
||
|
|
|
||
|
|
Pero rustc y cargo están ESCRITOS EN RUST
|
||
|
|
|
||
|
|
Entonces: ¿Cómo compilo Rust si necesito Rust para compilarlo?
|
||
|
|
|
||
|
|
┌─────────────────────┐
|
||
|
|
│ El Huevo y Gallina │
|
||
|
|
├─────────────────────┤
|
||
|
|
│ Necesito Rust → │
|
||
|
|
│ Para compilar → │
|
||
|
|
│ Rust │
|
||
|
|
│ │
|
||
|
|
│ ¿Cómo empiezo? │
|
||
|
|
└─────────────────────┘
|
||
|
|
|
||
|
|
LA SOLUCIÓN: Bootstrap Compiler (Compilador Pre-Compilado)
|
||
|
|
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
|
||
|
|
|
||
|
|
Rust proporciona binarios precompilados LISTOS PARA EJECUTAR:
|
||
|
|
|
||
|
|
https://sh.rustup.rs
|
||
|
|
↓
|
||
|
|
Script que descarga:
|
||
|
|
├─ rustc precompilado
|
||
|
|
├─ cargo precompilado
|
||
|
|
└─ Para tu sistema específico
|
||
|
|
|
||
|
|
Estos binarios están compilados EN LENGUAJE MÁQUINA
|
||
|
|
(no en Rust, sino en 1s y 0s para tu CPU)
|
||
|
|
|
||
|
|
Por eso puedes ejecutarlos sin tener Rust instalado!
|
||
|
|
|
||
|
|
════════════════════════════════════════════════════════════════════════════
|
||
|
|
|
||
|
|
¿QUÉ EXACTAMENTE ES https://sh.rustup.rs?
|
||
|
|
|
||
|
|
Es una URL que apunta a:
|
||
|
|
├─ Un SCRIPT bash
|
||
|
|
├─ Alojado en: https://sh.rustup.rs
|
||
|
|
├─ Descargable con: curl https://sh.rustup.rs
|
||
|
|
└─ Ejecutable con: bash
|
||
|
|
|
||
|
|
Cuando haces:
|
||
|
|
$ curl https://sh.rustup.rs | sh
|
||
|
|
|
||
|
|
Pasa esto:
|
||
|
|
|
||
|
|
1. curl descarga el archivo
|
||
|
|
2. bash lo ejecuta
|
||
|
|
|
||
|
|
El script contiene:
|
||
|
|
|
||
|
|
┌─────────────────────────────────────────────────────┐
|
||
|
|
│ #!/bin/bash │
|
||
|
|
│ │
|
||
|
|
│ # 1. Detecta tu arquitectura │
|
||
|
|
│ ARCH=$(uname -m) │
|
||
|
|
│ OS=$(uname -s) │
|
||
|
|
│ │
|
||
|
|
│ # 2. Descarga el toolchain precompilado │
|
||
|
|
│ if [ $ARCH = "arm64" ] && [ $OS = "Darwin" ]; then │
|
||
|
|
│ curl https://static.rust-lang.org/dist/ │
|
||
|
|
│ rust-stable-aarch64-apple-darwin.tar.gz \ │
|
||
|
|
│ -o rust.tar.gz │
|
||
|
|
│ fi │
|
||
|
|
│ │
|
||
|
|
│ # 3. Descomprime │
|
||
|
|
│ tar xzf rust.tar.gz │
|
||
|
|
│ │
|
||
|
|
│ # 4. Instala │
|
||
|
|
│ ./rust-installer/install.sh --prefix=$HOME/.rustup │
|
||
|
|
│ │
|
||
|
|
│ # 5. Configura PATH │
|
||
|
|
│ echo 'export PATH=$HOME/.cargo/bin:$PATH' >> │
|
||
|
|
│ ~/.bashrc │
|
||
|
|
│ │
|
||
|
|
└─────────────────────────────────────────────────────┘
|
||
|
|
|
||
|
|
════════════════════════════════════════════════════════════════════════════
|
||
|
|
|
||
|
|
PASO A PASO: QUÉ OCURRE CUANDO EJECUTAS
|
||
|
|
|
||
|
|
$ curl https://sh.rustup.rs | sh
|
||
|
|
|
||
|
|
PASO 1: Tu máquina descarga el script
|
||
|
|
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
|
||
|
|
|
||
|
|
Tu máquina (sin Rust)
|
||
|
|
↓
|
||
|
|
Ejecuta: curl https://sh.rustup.rs
|
||
|
|
↓
|
||
|
|
Se conecta a: sh.rustup.rs (servidor en internet)
|
||
|
|
↓
|
||
|
|
Descarga: Un archivo bash (~150 KB)
|
||
|
|
↓
|
||
|
|
Pasa a: bash (el shell de tu sistema)
|
||
|
|
|
||
|
|
PASO 2: El script detecta tu arquitectura
|
||
|
|
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
|
||
|
|
|
||
|
|
El script bash hace:
|
||
|
|
|
||
|
|
├─ uname -s → "Darwin" (si es macOS)
|
||
|
|
├─ uname -m → "arm64" (si es M1/M2/M3)
|
||
|
|
├─ Concatena: → "aarch64-apple-darwin"
|
||
|
|
└─ Determina: → "Necesito descargar Rust para aarch64-apple-darwin"
|
||
|
|
|
||
|
|
PASO 3: Descarga el toolchain precompilado
|
||
|
|
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
|
||
|
|
|
||
|
|
El script ejecuta:
|
||
|
|
|
||
|
|
curl https://static.rust-lang.org/dist/rust-stable-aarch64-apple-darwin.tar.gz \
|
||
|
|
-o /tmp/rust.tar.gz
|
||
|
|
|
||
|
|
Descarga:
|
||
|
|
├─ rustc (binario compilado para ARM64)
|
||
|
|
├─ cargo (binario compilado para ARM64)
|
||
|
|
├─ std library (librerías estándar compiladas para ARM64)
|
||
|
|
└─ ~500-700 MB
|
||
|
|
|
||
|
|
Esto NO es código fuente (.rs)
|
||
|
|
Esto es BINARIO EJECUTABLE (lenguaje máquina)
|
||
|
|
|
||
|
|
PASO 4: Descomprime el archive
|
||
|
|
━━━━━━━━━━━━━━━━━━━━━━━━━━━━
|
||
|
|
|
||
|
|
tar xzf /tmp/rust.tar.gz
|
||
|
|
↓
|
||
|
|
Crea directorio con:
|
||
|
|
├─ rust/
|
||
|
|
│ ├─ rustc (ejecutable)
|
||
|
|
│ ├─ cargo (ejecutable)
|
||
|
|
│ ├─ rust-std-aarch64-apple-darwin/ (librerías precompiladas)
|
||
|
|
│ └─ install.sh (script de instalación)
|
||
|
|
|
||
|
|
PASO 5: Ejecuta el instalador
|
||
|
|
━━━━━━━━━━━━━━━━━━━━━━━━━
|
||
|
|
|
||
|
|
./rust/install.sh --prefix=$HOME/.rustup
|
||
|
|
↓
|
||
|
|
Mueve archivos:
|
||
|
|
├─ ~/.rustup/toolchains/stable-aarch64-apple-darwin/bin/rustc
|
||
|
|
├─ ~/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo
|
||
|
|
└─ ~/.rustup/toolchains/stable-aarch64-apple-darwin/lib/...
|
||
|
|
|
||
|
|
PASO 6: Configura PATH
|
||
|
|
━━━━━━━━━━━━━━━━━━━
|
||
|
|
|
||
|
|
El script añade a ~/.bashrc o ~/.zshrc:
|
||
|
|
|
||
|
|
export PATH=$HOME/.cargo/bin:$PATH
|
||
|
|
↓
|
||
|
|
Esto hace que cargo esté accesible globalmente
|
||
|
|
|
||
|
|
PASO 7: LISTO! Ahora tienes Rust
|
||
|
|
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
|
||
|
|
|
||
|
|
$ rustc --version
|
||
|
|
rustc 1.75.0 (2024-02-13)
|
||
|
|
✅ FUNCIONA!
|
||
|
|
|
||
|
|
════════════════════════════════════════════════════════════════════════════
|
||
|
|
|
||
|
|
¿DÓNDE SE DESCARGAN ESTOS BINARIOS PRECOMPILADOS?
|
||
|
|
|
||
|
|
https://static.rust-lang.org/dist/
|
||
|
|
|
||
|
|
Este servidor tiene binarios precompilados para TODOS los targets:
|
||
|
|
|
||
|
|
rust-stable-aarch64-apple-darwin.tar.gz (Mac M1/M2/M3)
|
||
|
|
rust-stable-x86_64-apple-darwin.tar.gz (Mac Intel)
|
||
|
|
rust-stable-x86_64-unknown-linux-gnu.tar.gz (Linux x86_64)
|
||
|
|
rust-stable-aarch64-unknown-linux-gnu.tar.gz (Linux ARM64)
|
||
|
|
rust-stable-x86_64-pc-windows-gnu.tar.gz (Windows GNU)
|
||
|
|
rust-stable-x86_64-pc-windows-msvc.tar.gz (Windows MSVC)
|
||
|
|
... (más de 50 targets diferentes)
|
||
|
|
|
||
|
|
Cada archivo contiene:
|
||
|
|
├─ rustc compilado PARA ESE TARGET
|
||
|
|
├─ cargo compilado PARA ESE TARGET
|
||
|
|
└─ std library compilada PARA ESE TARGET
|
||
|
|
|
||
|
|
════════════════════════════════════════════════════════════════════════════
|
||
|
|
|
||
|
|
¿PERO ESPERA... ¿CÓMO SE COMPILARON ESOS BINARIOS?
|
||
|
|
|
||
|
|
Gran pregunta! Respuesta corta:
|
||
|
|
|
||
|
|
La Rust Foundation mantiene CI/CD servers que:
|
||
|
|
|
||
|
|
├─ Clonan el repo de Rust
|
||
|
|
├─ Compilan Rust CON Rust anterior
|
||
|
|
└─ Crean binarios para cada target
|
||
|
|
|
||
|
|
Ejemplo:
|
||
|
|
|
||
|
|
Rust 1.75.0 se compiló con:
|
||
|
|
Rust 1.74.0 (precompilado)
|
||
|
|
↓
|
||
|
|
Que se compiló con Rust 1.73.0
|
||
|
|
↓
|
||
|
|
Que se compiló con Rust 1.72.0
|
||
|
|
↓
|
||
|
|
... (hacia atrás en el tiempo)
|
||
|
|
↓
|
||
|
|
Hasta el primer Rust compilado con C++ (hace 10+ años)
|
||
|
|
|
||
|
|
Esto se llama "bootstrapping chain" (cadena de bootstrap)
|
||
|
|
|
||
|
|
════════════════════════════════════════════════════════════════════════════
|
||
|
|
|
||
|
|
DIAGRAMA VISUAL: EL FLUJO COMPLETO
|
||
|
|
|
||
|
|
Tu máquina sin Rust:
|
||
|
|
|
||
|
|
$ curl https://sh.rustup.rs | sh
|
||
|
|
↓
|
||
|
|
[Script 1: sh.rustup.rs - 150 KB bash script]
|
||
|
|
├─ Detecta: aarch64-apple-darwin
|
||
|
|
├─ Descarga: rust-stable-aarch64-apple-darwin.tar.gz
|
||
|
|
↓
|
||
|
|
[Descarga: 700 MB - Binarios precompilados ARM64]
|
||
|
|
├─ rustc (ejecutable ARM64)
|
||
|
|
├─ cargo (ejecutable ARM64)
|
||
|
|
├─ std library (compilada para ARM64)
|
||
|
|
↓
|
||
|
|
[Script 2: rust/install.sh - Installer]
|
||
|
|
├─ Descomprime
|
||
|
|
├─ Mueve a ~/.rustup/
|
||
|
|
├─ Configura PATH
|
||
|
|
↓
|
||
|
|
✅ Rust 1.75.0 instalado!
|
||
|
|
|
||
|
|
Ahora puedes:
|
||
|
|
$ rustc --version
|
||
|
|
rustc 1.75.0
|
||
|
|
|
||
|
|
$ cargo build --release
|
||
|
|
(Compila Rust projects desde source)
|
||
|
|
|
||
|
|
════════════════════════════════════════════════════════════════════════════
|
||
|
|
|
||
|
|
¿POR QUÉ PRECOMPILADOS Y NO DESDE FUENTE?
|
||
|
|
|
||
|
|
Razones:
|
||
|
|
|
||
|
|
1. VELOCIDAD
|
||
|
|
├─ Compilar Rust desde fuente toma 30+ minutos
|
||
|
|
└─ Descargar binario precompilado: 2-5 minutos
|
||
|
|
|
||
|
|
2. COMPLEJIDAD
|
||
|
|
├─ Compilar requiere: C++, LLVM, cmake, etc.
|
||
|
|
└─ Descargar es trivial: solo necesitas curl
|
||
|
|
|
||
|
|
3. ACCESIBILIDAD
|
||
|
|
├─ No todos tienen compilador C/C++
|
||
|
|
└─ Todos tienen curl
|
||
|
|
|
||
|
|
4. CONSISTENCIA
|
||
|
|
├─ Mismos binarios para todos (reproducibilidad)
|
||
|
|
└─ Sin variaciones por diferente compilador
|
||
|
|
|
||
|
|
════════════════════════════════════════════════════════════════════════════
|
||
|
|
|
||
|
|
ANALÓGÍA PARA ENTENDERLO MEJOR
|
||
|
|
|
||
|
|
Imagina que necesitas instalar un coche:
|
||
|
|
|
||
|
|
OPCIÓN 1: Compilar desde fuente (NO SE HACE)
|
||
|
|
├─ Necesitas: fábrica de coches, tornos, herramientas
|
||
|
|
├─ Necesitas: metales, cauchos, vidrios crudos
|
||
|
|
├─ Tiempo: 6 meses
|
||
|
|
└─ Complejo: casi imposible sin experiencia
|
||
|
|
|
||
|
|
OPCIÓN 2: Descargar precompilado (LO QUE RUST HACE)
|
||
|
|
├─ Ya existe: un coche terminado
|
||
|
|
├─ Solo necesitas: bajarlo de la grúa
|
||
|
|
├─ Tiempo: 2 horas
|
||
|
|
└─ Fácil: cualquiera puede hacerlo
|
||
|
|
|
||
|
|
Rust elige OPCIÓN 2 para bootstrap:
|
||
|
|
├─ Los desarrolladores de Rust compilan Rust
|
||
|
|
├─ Lo suben a sh.rustup.rs
|
||
|
|
├─ Tú descargas el binario terminado
|
||
|
|
└─ Tu máquina ya puede compilar código Rust
|
||
|
|
|
||
|
|
════════════════════════════════════════════════════════════════════════════
|
||
|
|
|
||
|
|
AHORA ENTIENDES EL FLUJO COMPLETO:
|
||
|
|
|
||
|
|
1. Sin Rust:
|
||
|
|
$ curl https://sh.rustup.rs | sh
|
||
|
|
↓
|
||
|
|
Descarga binario precompilado
|
||
|
|
|
||
|
|
2. Con Rust instalado:
|
||
|
|
$ cargo build --release
|
||
|
|
↓
|
||
|
|
Compila Rust projects desde SOURCE
|
||
|
|
↓
|
||
|
|
Genera binarios COMPILADOS POR TI para tu máquina
|
||
|
|
|
||
|
|
3. En install.sh:
|
||
|
|
# Fase 2:
|
||
|
|
curl https://sh.rustup.rs | sh
|
||
|
|
↓ (Rust se instala)
|
||
|
|
|
||
|
|
# Fase 4:
|
||
|
|
cargo build --release --workspace
|
||
|
|
↓ (Ahora cargo está disponible)
|
||
|
|
|
||
|
|
# Compila workspace desde source
|
||
|
|
target/release/workspace (binario compilado localmente)
|
||
|
|
|
||
|
|
════════════════════════════════════════════════════════════════════════════
|
||
|
|
|
||
|
|
RESUMEN EN UNA FRASE:
|
||
|
|
|
||
|
|
"https://sh.rustup.rs es un script que descarga binarios precompilados
|
||
|
|
de Rust para tu arquitectura y los instala en tu máquina,
|
||
|
|
rompiendo el ciclo infinito de 'necesito Rust para instalar Rust'"
|
||
|
|
|
||
|
|
════════════════════════════════════════════════════════════════════════════
|
||
|
|
|
||
|
|
|
||
|
|
╔════════════════════════════════════════════════════════════════════════════╗
|
||
|
|
║ DEMO EN VIVO: Qué es realmente sh.rustup.rs ║
|
||
|
|
╚════════════════════════════════════════════════════════════════════════════╝
|
||
|
|
|
||
|
|
Vamos a ver el primer kilobyte del script real:
|
||
|
|
|
||
|
|
EOF
|
||
|
|
|
||
|
|
echo ""
|
||
|
|
echo "1. Descargando las primeras líneas del script:"
|
||
|
|
echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
|
||
|
|
echo ""
|
||
|
|
|
||
|
|
curl -s https://sh.rustup.rs | head -50 | cat
|