syntaxis/bootstrap_rust.md at main

Jesús Pérez 9cef9b8d57 refactor: consolidate configuration directories

Merge _configs/ into config/ for single configuration directory.
Update all path references.

Changes:
- Move _configs/* to config/
- Update .gitignore for new patterns
- No code references to _configs/ found

Impact: -1 root directory (layout_conventions.md compliance)

2025-12-26 18:36:23 +00:00

15 KiB

Raw Permalink Blame History

╔════════════════════════════════════════════════════════════════════════════╗ ║ ¿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:

VELOCIDAD ├─ Compilar Rust desde fuente toma 30+ minutos └─ Descargar binario precompilado: 2-5 minutos
COMPLEJIDAD ├─ Compilar requiere: C++, LLVM, cmake, etc. └─ Descargar es trivial: solo necesitas curl
ACCESIBILIDAD ├─ No todos tienen compilador C/C++ └─ Todos tienen curl
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:

Sin Rust: $ curl https://sh.rustup.rs | sh ↓ Descarga binario precompilado
Con Rust instalado: $ cargo build --release ↓ Compila Rust projects desde SOURCE ↓ Genera binarios COMPILADOS POR TI para tu máquina
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

15 KiB Raw Permalink Blame History

Fase 2:

Fase 4:

Compila workspace desde source

15 KiB

Raw Permalink Blame History