Migra de Bash a Rust. Procesa millones de líneas en segundos

Vistas: 1098
0:00 / 0:00
Migra de Bash a Rust. Procesa millones de líneas en segundos

El objetivo de este episodio es ofrecer una guía práctica para migrar scripts de Bash a Rust-script, destacando las diferencias clave en la gestión de estados, argumentos, validación, comandos, rutas, variables de entorno, generación de logs, lectura de archivos y concurrencia. Soy consciente que explicar este tema en un episodio es algo realmente complicado y difícil de seguir, por lo que he todos los ejemplos, los he dejado en las notas del episodio. De cualquier forma, como sabes me gustan los retos, esto es un auténtico reto, y difícil de conseguir. Así que vamos a ello.

Migra de Bash a Rust. Procesa millones de líneas en segundos

Migra de Bash a Rust. Procesa millones de líneas en segundos

Gestión de estados y errores (status)

En Bash, dependemos de la inspección manual de la variable $?. En Rust, el manejo de errores es parte del flujo natural del código.

  • Bash (0_status.sh): Utiliza un bloque condicional if [ $? -ne 0 ] después de ejecutar mkdir para verificar si la operación falló.
  • Rust (0_status.rsc): El operador ? sustituye por completo al condicional de Bash. Si la función fs::create_dir falla, el script termina inmediatamente y propaga el error de forma automática.
  • Ventaja: El código es mucho más limpio y es imposible olvidar gestionar un error, ya que el compilador te obliga a manejar el tipo Result.
#!/bin/bash

# Intentamos crear un directorio
mkdir /root/test_dir 2>/dev/null

if [ $? -ne 0 ]; then
    echo "Error: No se pudo crear el directorio."
    exit 1
fi

echo "Directorio creado con éxito."
#!/usr/bin/env rust-script

use std::fs;
use std::io;

fn main() -> io::Result<()> {
    // El operador '?' sustituye al 'if [ $? -eq 0 ]'
    // Si mkdir falla, el script termina aquí y devuelve el error
    fs::create_dir("/root/test_dir")?;

    println!("Directorio creado con éxito.");

    Ok(())
}

Paso de argumentos

Bash trata todo como cadenas de texto, lo que obliga a validaciones manuales complejas. Rust ofrece seguridad de tipos desde el primer momento.

  • Bash (1_argumentos.sh): Requiere comprobar el número de argumentos ($#) y usar expresiones regulares para validar que un argumento sea un número antes de usarlo en un bucle.
  • Rust (1_argumentos.rsc): Utiliza iteradores para extraer valores (args.next()). Al usar .parse()?, Rust realiza la conversión a un tipo numérico y la validación de errores en un solo paso.
  • Ventaja: Evitas errores en tiempo de ejecución causados por datos mal formados, capturándolos en el momento del parseo.
#!/bin/bash

# Comprobar si hay suficientes argumentos
if [ "$#" -ne 2 ]; then
    echo "Uso: $0 <nombre> <repeticiones>"
    exit 1
fi

NOMBRE=$1
REPETICIONES=$2

# Validar si es un número (Bash no tiene tipos, hay que usar Regex o trucos)
if ! [[ "$REPETICIONES" =~ ^[0-9]+$ ]]; then
    echo "Error: $REPETICIONES no es un número válido"
    exit 1
fi

for i in $(seq 1 $REPETICIONES); do
    echo "Hola $NOMBRE, esta es la vez $i"
done
#!/usr/bin/env rust-script

use std::env;

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let mut args = env::args().skip(1); // Saltamos el nombre del script

    // Extraemos los valores o lanzamos error si faltan
    let nombre = args.next().ok_or("Falta el argumento: <nombre>")?;
    let repeticiones: u32 = args.next()
        .ok_or("Falta el argumento: <repeticiones>")?
        .parse()?;

    for i in 1..=repeticiones {
        println!("{i}.- Hola {nombre}");
    }

    Ok(())
}

Validación

La validación en Rust es semántica y exhaustiva, a diferencia de los condicionales lógicos de Bash.

  • Bash (2_validacion.sh): Combina Regex con operadores lógicos (&&) para validar rangos numéricos.
  • Rust (2_validacion.rsc): Utiliza match para validar el parseo y el rango matemático de forma simultánea.
  • Ventaja: El Pattern Matching permite cubrir todos los casos posibles de forma explícita, mejorando la legibilidad y seguridad del script.
#!/bin/bash
EDAD=$1
if [[ "$EDAD" =~ ^[0-9]+$ ]] && [ "$EDAD" -ge 0 ] && [ "$EDAD" -le 120 ]; then
    echo "Edad válida"
else
    echo "Entrada inválida"
fi
#!/usr/bin/env rust-script

fn main() {
    let entrada = "25"; // Vendría de un argumento

    // El parseo ya descarta texto no numérico. 
    // Luego validamos el rango de forma matemática.
    match entrada.parse::<u8>() {
        Ok(edad) if (0..=120).contains(&edad) => println!("Edad válida: {edad}"),
        _ => eprintln!("Error: La edad debe ser un número entre 0 y 120"),
    }
}

Comandos

Capturar la salida de un comando externo requiere transformar bytes en texto con sentido.

  • Bash (3_comando.sh): La sintaxis $(…) captura la salida y elimina el salto de línea automáticamente.
  • Rust (3_comando.rsc): Utiliza Command::new().output()? para ejecutar el proceso. Es necesario convertir explícitamente los bytes (u8) a String y usar .trim() para igualar el comportamiento de Bash.
  • Ventaja: Rust es más seguro frente a inyecciones de comandos, ya que separa el ejecutable de los argumentos.
#!/bin/bash
# Captura la salida (quita el \n automáticamente)
FECHA=$(date +%Y-%m-%d)
# Imprime el resultado
echo "Hoy es: $FECHA"
#!/usr/bin/env rust-script

use std::process::Command;

fn main() -> Result<(), Box<dyn std::error::Error>> {
    // 1. Ejecutamos y capturamos (equivalente a $(...))
    let salida = Command::new("date").arg("+%Y-%m-%d").output()?;

    // 2. Convertimos bytes a String y limpiamos el \n final (como hace Bash)
    let fecha = String::from_utf8(salida.stdout)?.trim().to_string();

    // 3. Imprimimos (equivalente a echo)
    println!("Hoy es: {fecha}");

    Ok(())
}

Rutas

Bash trata las rutas como simples cadenas, lo que causa errores críticos si existen espacios. Rust utiliza objetos con conciencia estructural.

  • Bash (5_rutas.sh): Requiere un uso meticuloso de comillas dobles («$RUTA») para evitar que el intérprete divida la ruta al encontrar espacios.
  • Rust (5_rutas.rsc): Utiliza PathBuf, que gestiona la construcción de la ruta de forma interna y añade los separadores necesarios automáticamente.
  • Ventaja: Eliminas errores accidentales por nombres de archivos «extraños» y aseguras que el script funcione correctamente en diferentes sistemas operativos.
#!/bin/bash
DIR="mi carpeta con espacios"
FICHERO="notas.txt"
# Si olvidas las comillas en "$DIR/$FICHERO", el script falla
RUTA="$DIR/$FICHERO"
touch "$RUTA"
#!/usr/bin/env rust-script
use std::path::PathBuf;

fn main() {
    let mut ruta = PathBuf::from("mi carpeta con espacios");
    ruta.push("notas.txt"); // Añade la barra / automáticamente
    println!("Ruta lista para usar: {}", ruta.display());
}

Variables de entorno

La gestión de valores por defecto es más legible y menos propensa a errores sintácticos en Rust.

  • Bash (6_variables_entorno.sh): Emplea la expansión de parámetros ${VARIABLE:-default}, una sintaxis potente pero críptica para usuarios noveles.
  • Rust (6_variables_entorno.rsc): Usa env::var().unwrap_or_else(), un método que define claramente qué hacer si la variable no existe.
  • Ventaja: El código se vuelve autodocumentado y facilita la depuración de configuraciones faltantes.
#!/bin/bash
# Sintaxis críptica para el usuario medio
LOG_LEVEL=${LOG_LEVEL:-"info"}
echo "Nivel de log: $LOG_LEVEL"
#!/usr/bin/env rust-script
use std::env;

fn main() {
    // Intentamos leer la variable, si no existe o es inválida, usamos el default
    let log_level = env::var("LOG_LEVEL").unwrap_or_else(|_| "info".into());
    println!("Nivel de log: {log_level}");
}

Generar un log

import random
import time
from datetime import datetime

# Configuración
FILENAME = "access_log.txt"
LINES_COUNT = 2000000

# Datos para aleatoriedad
LOG_LEVELS = ["INFO", "DEBUG", "WARNING", "ERROR", "CRITICAL"]
IPS = [f"192.168.1.{i}" for i in range(1, 255)]
MESSAGES = [
    "User logged in successfully",
    "Failed login attempt",
    "Database connection established",
    "Timeout waiting for response",
    "File uploaded: /uploads/image.png",
    "Disk usage above 80%",
    "API request received: GET /v1/users",
    "Session expired for user_id: 4502"
]

def generate_logs():
    print(f"Generando {LINES_COUNT} líneas en '{FILENAME}'...")
    start_time = time.time()

    with open(FILENAME, "w", encoding="utf-8") as f:
        for _ in range(LINES_COUNT):
            timestamp = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
            level = random.choice(LOG_LEVELS)
            ip = random.choice(IPS)
            msg = random.choice(MESSAGES)

            # Formato: [TIMESTAMP] [LEVEL] IP: MESSAGE
            f.write(f"[{timestamp}] [{level}] {ip}: {msg}\n")

    end_time = time.time()
    print(f"¡Listo! Tiempo transcurrido: {end_time - start_time:.2f} segundos.")

if __name__ == "__main__":
    generate_logs()
#!/usr/bin/env rustscript
//! ``cargo
//! [dependencies]
//! rand = "0.8"
//! chrono = "0.4"
//! ``
use std::fs::File;
use std::io::{BufWriter, Write};
use std::time::Instant;
use rand::seq::SliceRandom; // Necesitas la crate 'rand'

fn main() -> std::io::Result<()> {
    let path = "access_log.txt";
    let num_lines = 2_000_000;

    // Datos aleatorios
    let levels = ["INFO", "DEBUG", "WARNING", "ERROR", "CRITICAL"];
    let ips = ["192.168.1.10", "10.0.0.5", "172.16.0.20", "192.168.1.50"];
    let messages = [
        "User logged in successfully",
        "Failed login attempt",
        "Database connection established",
        "Timeout waiting for response",
        "Disk usage above 80%",
    ];

    let start = Instant::now();
    let file = File::create(path)?;
    let mut writer = BufWriter::new(file);

    let mut rng = rand::thread_rng();

    for _ in 0..num_lines {
        let level = levels.choose(&mut rng).unwrap();
        let ip = ips.choose(&mut rng).unwrap();
        let msg = messages.choose(&mut rng).unwrap();

        // Usamos writeln! para agregar el salto de línea automáticamente
        writeln!(
            writer,
            "[{:?}] [{}] {}: {}",
            chrono::Local::now().format("%Y-%m-%d %H:%M:%S"),
            level,
            ip,
            msg
        )?;
    }

    // Asegurar que todo se escriba al disco
    writer.flush()?;

    let duration = start.elapsed();
    println!("¡Listo! 100,000 líneas generadas en {:?}", duration);

    Ok(())
}

Leer archivos

Cuando pasas de miles a millones de líneas, la velocidad y la gestión de memoria de Rust no tienen competencia.

  • Bash (8_leer_archivo.sh): El bucle while read es extremadamente lento para procesar millones de líneas, ya que invoca procesos internos en cada iteración.
  • Rust (8_leer_archivo.rsc): Utiliza BufReader, que lee el archivo en bloques (buffers), permitiendo un procesamiento casi instantáneo sin saturar la RAM.
  • Ventaja: Una tarea que en Bash puede tardar minutos, en Rust se completa en segundos, permitiendo scripts de mantenimiento mucho más ambiciosos.
#!/bin/bash
while IFS= read -r linea; do
    if [[ "$linea" == *"ERROR"* ]]; then
        echo "Cuidado: $linea"
    fi
done < access_log.txt
#!/usr/bin/env rust-script
use std::fs::File;
use std::io::{self, BufRead};

fn main() -> io::Result<()> {
    let archivo = File::open("access_log.txt")?;
    let lector = io::BufReader::new(archivo);

    for linea in lector.lines() {
        let l = linea?; // Manejo de error si la línea es corrupta
        if l.contains("ERROR") {
            println!("Cuidado: {l}");
        }
    }
    Ok(())
}

Hilos y concurrencia

Paralelizar tareas es el punto donde Rust ofrece una arquitectura de ingeniería superior.

  • Bash (9_hilos.sh): Lanza procesos al fondo con & y usa wait para sincronizar. El problema es que lanza 50 procesos ping pesados simultáneamente sin control de recursos.
  • Rust (9_hilos.rsc): Crea hilos ligeros del sistema con thread::spawn y utiliza move para transferir la propiedad de los datos de forma segura. Finalmente, sincroniza todo con .join().
  • Ventaja: Tienes un control total sobre el ciclo de vida de cada hilo y evitas la saturación de procesos que podría causar una «fork bomb» accidental en Bash si la lista de servidores creciera masivamente.
#!/bin/bash

SERVIDORES=(
    "google.com" "github.com" "atareao.es" "rust-lang.org" "linux.org"
    "debian.org" "archlinux.org" "ubuntu.com" "fedora.org" "kernel.org"
    "duckduckgo.com" "bing.com" "yahoo.com" "wikipedia.org" "wikimedia.org"
    "youtube.com" "vimeo.com" "twitch.tv" "netflix.com" "spotify.com"
    "amazon.com" "ebay.com" "aliexpress.com" "microsoft.com" "apple.com"
    "facebook.com" "instagram.com" "twitter.com" "linkedin.com" "reddit.com"
    "cloudflare.com" "digitalocean.com" "linode.com" "hetzner.com" "ovh.com"
    "docker.com" "kubernetes.io" "ansible.com" "terraform.io" "gitlab.com"
    "stackoverflow.com" "medium.com" "dev.to" "hackernews.com" "slashdot.org"
    "nytimes.com" "bbc.com" "elpais.com" "elmundo.es" "nasa.gov"
)

comprobar_ping() {
    if ping -c 1 -W 1 "$1" > /dev/null 2>&1; then
        echo "✅ $1 está vivo"
    else
        echo "❌ $1 está caído"
    fi
}

echo "Lanzando ${#SERVIDORES[@]} comprobaciones al fondo..."

for ip in "${SERVIDORES[@]}"; do
    # Lanzamos en segundo plano con &
    comprobar_ping "$ip" &
done

# Esperamos a que todos los procesos hijos terminen
wait

echo "Monitorización finalizada."
#!/bin/bash

SERVIDORES=(
    "google.com" "github.com" "atareao.es" "rust-lang.org" "linux.org"
    "debian.org" "archlinux.org" "ubuntu.com" "fedora.org" "kernel.org"
    "duckduckgo.com" "bing.com" "yahoo.com" "wikipedia.org" "wikimedia.org"
    "youtube.com" "vimeo.com" "twitch.tv" "netflix.com" "spotify.com"
    "amazon.com" "ebay.com" "aliexpress.com" "microsoft.com" "apple.com"
    "facebook.com" "instagram.com" "twitter.com" "linkedin.com" "reddit.com"
    "cloudflare.com" "digitalocean.com" "linode.com" "hetzner.com" "ovh.com"
    "docker.com" "kubernetes.io" "ansible.com" "terraform.io" "gitlab.com"
    "stackoverflow.com" "medium.com" "dev.to" "hackernews.com" "slashdot.org"
    "nytimes.com" "bbc.com" "elpais.com" "elmundo.es" "nasa.gov"
)

# Definimos la lógica en una función
comprobar_ping() {
    if ping -c 1 -W 1 "$1" > /dev/null 2>&1; then
        echo "✅ $1 está vivo"
    else
        echo "❌ $1 está caído"
    fi
}

# Exportamos la función para que parallel la reconozca
export -f comprobar_ping

# Ejecutamos en paralelo
# ::: pasa los elementos del array como argumentos
printf "%s\n" "${SERVIDORES[@]}" | parallel comprobar_ping
#!/usr/bin/env rust-script

use std::process::Command;
use std::thread;

fn main() {
    let servidores = vec![
        "google.com", "github.com", "atareao.es", "rust-lang.org", "linux.org",
        "debian.org", "archlinux.org", "ubuntu.com", "fedora.org", "kernel.org",
        "duckduckgo.com", "bing.com", "yahoo.com", "wikipedia.org", "wikimedia.org",
        "youtube.com", "vimeo.com", "twitch.tv", "netflix.com", "spotify.com",
        "amazon.com", "ebay.com", "aliexpress.com", "microsoft.com", "apple.com",
        "facebook.com", "instagram.com", "twitter.com", "linkedin.com", "reddit.com",
        "cloudflare.com", "digitalocean.com", "linode.com", "hetzner.com", "ovh.com",
        "docker.com", "kubernetes.io", "ansible.com", "terraform.io", "gitlab.com",
        "stackoverflow.com", "medium.com", "dev.to", "hackernews.com", "slashdot.org",
        "nytimes.com", "bbc.com", "elpais.com", "elmundo.es", "nasa.gov"
    ];
    let mut hilos = vec![];

    for ip in servidores {
        // Creamos un hilo por cada IP
        let hilo = thread::spawn(move || {
            let status = Command::new("ping")
                .args(["-c", "1", "-W", "1", ip])
                .stdout(std::process::Stdio::null()) // Silenciamos la salida
                .stderr(std::process::Stdio::null())
                .status();

            match status {
                Ok(s) if s.success() => println!("✅ {ip} está vivo"),
                _ => println!("❌ {ip} está caído o no responde"),
            }
        });
        hilos.push(hilo);
    }

    // El "colofón": esperar a que todos terminen antes de cerrar el script
    for h in hilos {
        let _ = h.join(); 
    }

    println!("Monitorización finalizada.");
}
#!/usr/bin/env rust-script

//! ``cargo
//! [dependencies]
//! rayon = "1.8"
//! ``

use rayon::prelude::*;
use std::process::Command;
use std::process::Stdio;

fn main() {
    let servidores = vec![
        "google.com", "github.com", "atareao.es", "rust-lang.org", "linux.org",
        "debian.org", "archlinux.org", "ubuntu.com", "fedora.org", "kernel.org",
        "duckduckgo.com", "bing.com", "yahoo.com", "wikipedia.org", "wikimedia.org",
        "youtube.com", "vimeo.com", "twitch.tv", "netflix.com", "spotify.com",
        "amazon.com", "ebay.com", "aliexpress.com", "microsoft.com", "apple.com",
        "facebook.com", "instagram.com", "twitter.com", "linkedin.com", "reddit.com",
        "cloudflare.com", "digitalocean.com", "linode.com", "hetzner.com", "ovh.com",
        "docker.com", "kubernetes.io", "ansible.com", "terraform.io", "gitlab.com",
        "stackoverflow.com", "medium.com", "dev.to", "hackernews.com", "slashdot.org",
        "nytimes.com", "bbc.com", "elpais.com", "elmundo.es", "nasa.gov"
    ];

    println!("Iniciando comprobación paralela con Rayon de {} servidores...", servidores.len());

    // AQUÍ ESTÁ LA MAGIA: .into_par_iter() en lugar de .into_iter()
    servidores.into_par_iter().for_each(|ip| {
        let status = Command::new("ping")
            .args(["-c", "1", "-W", "1", ip])
            .stdout(Stdio::null())
            .stderr(Stdio::null())
            .status();

        match status {
            Ok(s) if s.success() => println!("✅ {ip} está vivo"),
            _ => println!("❌ {ip} está caído o no responde"),
        }
    });

    println!("Monitorización finalizada en tiempo récord.");
}

Comparativa

CaracterísticaBashRust-scriptPor qué ganarás
Manejo de ErroresInspección manual de la variable $?Uso del operador ? y tipo ResultEl script se detiene ante errores automáticamente, evitando fallos en cadena.
Paso de ArgumentosValidación manual con expresiones regularesTipado fuerte y método .parse()Aseguras que los datos de entrada (como números) son válidos antes de procesarlos.
Lógica de DatosCondicionales if/else y lógica de textomatch y Pattern Matching exhaustivoCubres todos los casos posibles (rangos, errores) de forma explícita y legible.
Captura de SalidaCaptura implícita y limpieza con $(...)Control manual de stdout y bytesControl total sobre la codificación (UTF-8) y el tratamiento de la salida del sistema.
Consumo de APIsDependencia externa de herramientas como jqSerialización integrada con serde_jsonScript autocontenido; procesas datos JSON de forma segura sin fallos silenciosos.
Gestión de RutasConcatenación de cadenas de textoUso de objetos PathBufEvitas que un espacio en un nombre de archivo rompa la lógica del script.
Variables de EntornoExpansión de parámetros ${VARIABLE:-default}Métodos funcionales Result / OptionEl código explica por sí mismo qué ocurre si la configuración no existe.
Escritura MasivaRedirecciones de shell (>>) o echoBufWriter para escritura en bloquesGeneración de millones de líneas con rendimiento profesional y bajo consumo.
Lectura de ArchivosBucle while read (lento en archivos grandes)BufReader para lectura eficienteProcesas archivos de logs de Gigabytes en segundos sin saturar la memoria RAM.
ConcurrenciaProcesos al fondo mediante & y waitHilos nativos seguros con std::threadEjecución de tareas paralelas (como pings) de forma coordinada, rápida y segura.

Que no se me olvide…. El primer episodio de La Era de las Distros

Ver el vídeo de este episodio
Transcripción

Hola soy lorenzo y esto es atareado con Linux episodio número 763 en el episodio 761 te,

Hablé de por qué o qué razones había para hacer determinados scripts en rast script en,

Verde en base en este episodio pues te voy a dar algunas pautas algunas ideas algunos conceptos,

Para que esa migración ese cambio de bus a rast script sea sencillo y tenga y tenga sentido quiero,

Decir al final hay determinados aspectos por los que un script debería de continuar siendo estando,

Implementado en bus y otros scripts pues tienen más sentido que estén por ejemplo en rast script en,

Python o como tú quieras pero lo que está claro es que hay determinadas ideas determinadas determinados,

Conceptos que sí que deberías de aplicar con independencia de la longitud o de la complejidad,

Del script al que te vayas a enfrentar así en este episodio te voy a intentar dar algunas ideas,

Algunos tips sobre esos 10 puntos para realizar la migración de bus a rast script y tómatelo como,

Eso como simplemente puntos ideas conceptos que deberías de aplicar o la solución que puedes,

Utilizar para esto en lugar de continuar con base así que me voy a enfrentar a un episodio realmente,

Complejo porque contar todo esto pues no te creas que tiene su miga y esperemos que consiga retenerte,

Por lo menos hasta el minuto 3 o el minuto 4 va a ser algo complejo pero como te digo al final me,

Gustan los retos y me gustan las cosas realmente complicadas así que vamos directos al turrón en,

Este episodio te voy a hablar sobre una guía de migración de bus a rast y empiezo pues empiezo por bueno,

Lo primero y principal en este episodio he conseguido incorporar o reincorporar la música de entrada y,

Salida en otros episodios en los últimos dos o tres episodios por por lo que fuera bueno por lo,

Que fuera no porque lo tenía muteado pues por eso no salía pero bueno aquí ya está así que como te,

Digo vamos vamos al lío y lo primero es pues la gestión de estados y errores en cualquier script al,

Final muchas de las operaciones que haces deber de comprobar si esa operación se ha realizado de,

Forma correcta o no se ha realizado de forma correcta por ejemplo cuando creas un directorio,

Pues es interesante darle feedback al usuario y decirle oye que el directorio se ha creado y si,

No se ha creado porque no se ha creado esto por ponerte un ejemplo no pero valdría para cualquier,

Otro comando que quieras ejecutar ya sea una ejecución o simplemente como te digo crear un directorio,

Qué es lo que sucede bueno pues lo que sucede es que habitualmente para este tipo de cosas pues,

Tienes que utilizar en base un condicional es decir utilizas el dólar interrogante para saber si el,

Resultado es un cero que entonces el resultado del script en base es correcto y si no pues ya sabes que,

Que el ha sido ha sido fallo en en rast esto es completamente distinto porque bueno completamente,

Distinto no pero en rast lo que tienes es el operador interrogante y ese operador interrogante,

Realmente simplifica mucho las operaciones simplemente con que tú le digas crear un directorio,

Él al final te va a generar un o sea una vez ha ejecutado ese comando lo que genera es una estructura,

De tipo result o mejor dicho un en una enumeración de tipo result que puede ser ok o error en el caso,

De que sea ok pues ya lo tienes claro en el caso de que sea error también lo tienes claro entonces lo,

Que antes se había convertido en un condicional aquí en este caso es simplemente un operador con lo,

Cual realmente las estructuras quedan súper sencillas independientemente con esto si comparas uno con el,

Otro que te digo que están todos los ejemplos que de los que voy a hablar en este episodio están en,

Las notas del episodio además con una comparativa al final de todas las cosas para que te quede claro,

Bueno si comparas una cosa con la otra verás que prácticamente son exactamente lo mismo que no hemos,

Ahorrado ni siquiera una línea y sin embargo si te fijas se simplifica considerablemente una operación a,

Otra luego al final esto es tan sencillo como ejecutarlo si ejecutas en el archivo el status como,

Le he llamado status sh pues te va a decir que no se puede crear el directorio porque ya lo he hecho,

Para que no se pueda crear y si lo ejecutas en rast lo que te dice es más información no solamente te dice,

Que te ha dado un error sino que además te dice que no tienes permiso para hacerlo esto sería la,

Gestión de estados es decir saber el resultado de una determinada operación otra de las cosas que,

Habitualmente vas a tener que hacer es pasar argumentos sí que hay comandos como por ejemplo,

Cd que no necesita bueno cd justo también necesita un argumento y eco también bueno en fin que para,

Cualquier comando para cualquier script o sea hay script que no necesitan que le pases ningún tipo de,

Argumento pero normalmente por lo general lo habitual es que le tengas que pasar algún tipo de,

Argumento por ejemplo si lo que quieres es hacer un repetir una palabra un número de veces pues,

Tienes que pasarle dos argumentos el lo que quieres repetir y el número de veces que lo quieres,

Repetir esto en el caso de de bus es realmente sencillo y en el caso de rast también,

En el caso de rast para el paso de argumentos,

Y en el caso de rast para el paso de argumentos la cuestión es que,

Es bastante como te digo es bastante sencillo de hacer simplemente en el caso de bus lo que vas a,

Hacer primero preguntarle cuántos argumentos tienes y en caso de que no tengas suficientes argumentos vas a,

Lanzar un mensaje de error y luego tienes que comprobar que el número de repeticiones es un,

Número o sea un entero o mejor dicho cumple una expresión regular del tipo que lo que le estás,

Pasando son números del cero al lo que sea y claro y si no has metido el nombre también va a dar un error,

Vale entonces lo primero que te encuentras aquí es que te tienes que pelear con las expresiones,

Regulares para verificar que los parámetros que le estás pasando son correctos luego tienes que,

Utilizar otra vez el tema de los condicionales de los que ya he hablado en el en la sección anterior,

En el sentido de que vas a tener que utilizar un condicional preguntarle si si el resultado es,

Correcto si no es correcto en fin todo ese tipo de operaciones de nuevo aquí hacemos uso,

Básicamente del operador interrogante que lo que nos va a permitir es precisamente ahorrarnos,

Condicionales básicamente si miras si comparas una cosa con la otra si comparas el script en,

Bus con el script en rush script lo que te vas a encontrar en el de bus son dos condicionales,

Mientras que en el caso del rush script lo que te vas a encontrar son dos dos como te diría dos,

Instrucciones claras no le pasas por un lado intentas obtener el nombre y en caso de que no lo encuentres,

Directamente te va a decir oye no encuentro el nombre y luego cuando le pases el número de repeticiones,

Lo va a intentar convertir directamente a un entero y en caso de que no lo pueda convertir a un entero,

Te va a decir también el error y si falta el argumento también te lo va a decir,

Luego el bucle prácticamente es lo mismo en uno y otro pero la simplicidad con la que se compara,

Una cosa con la otra pues lo cierto es que cuando lo miras de un solo vistazo ya tienes claro qué es,

Lo que está haciendo uno y el otro es un poquito más complejo repito al final todo esto son cosas que,

Simplemente las vas a ver un poco o sea me refiero que si comparas estos dos scripts vas a decir hombre,

Pues tampoco nos ahorramos tanto entre uno y el otro pero luego a la hora de mantener este que,

Tenerlo en cuenta y al final estos son solamente tips de cómo deberías de hacerlo para cuando tienes,

Que pasar muchos más variables por ejemplo en este caso simplemente hemos pasado un par de variables pero,

Si tienes que pasar más probablemente para el caso de que tengas que pasar muchas más variables ahí lo que,

Tenga sentido es utilizar algún tipo de crate que te permita hacer esto de una manera mucho más sencilla,

Pero bueno esto es para que te hagas al final como te digo una idea luego el siguiente,

El siguiente de los de las de las cuestiones hemos visto los estados los argumentos ahora tocaría,

Lo que son las validaciones las validaciones tanto en rast como en vash entonces para el tema de las validaciones por ejemplo vamos a hacer una validación que sea muy sencilla no simplemente vamos a preguntar una edad entonces para comprobar que esa edad es válida pues lo que,

Es lo que tienes que hacer primero tienes que asegurar que el parámetro que le has pasado es un número entero,

Luego estamos preguntando por una edad con lo cual la edad tiene que ser por lo menos mayor o sea como mínimo tiene que ser mayor de cero y luego por otro lado también pues deberíamos de mirar por la parte superior,

Es decir por ejemplo que no nos pongamos más de 120 años por ejemplo esto por decirte cómo se resuelve esto pues esto se resuelve básicamente con una expresión regular y con un par de condiciones adicionales,

De nuevo entramos en el mundo de las expresiones regulares que como bien sabes es un mundo bastante tenebroso para mucha gente,

En el caso de rast script la cosa se simplifica bastante porque aquí lo primero que haces es un parseo de manera que si lo que le estás enviando ya no es un número te va a dar un error,

Lo siguiente es que si como le estás paseando como un número entero si es un número que no es que es negativo ya te va a dar otro error,

Y además lo valida contra que sea entre cero y 120 y ahí ya lo tienes completamente resuelto de nuevo es simplemente,

Una operación de matcheo que a mí inicialmente cuando empecé con todo esto me parecía algo un poco complejo pero actualmente bueno,

Es muy cómodo trabajar con ello lo siguiente va a ser los comandos,

Para el tema de los comandos simplemente esta es otra de las operaciones habituales que se suelen hacer el tema de los comandos es lo más normal,

Que tengas que hacer así para el tema de los comandos lo primero evidentemente es en el caso de bash por ejemplo yo he hecho,

Un ejemplo muy claro que es ejecutar un date que es realmente sencillo de hecho si miras el script en bash vas a decir,

Ostras pero si es que es mucho más sencillo que hacerlo en bash que en rast script,

En bash tienes que utilizar la estructura del tipo dólar y paréntesis para capturar la salida y eliminar el salto de línea,

Mientras que en rast script utilizas una herramienta que se llama command y con command y output ejecutas y extraes el proceso,

Además es necesario convertir de manera explícita los bytes a string y además hacer un trim para igualar exactamente el comportamiento,

¿Qué ventaja tienes con toda esta parafernalia que hemos montado simplemente al pasar de bash a rast script.

Bueno rast script es mucho más seguro en inyecciones de comandos ya que separa el ejecutable de los argumentos,

Aquí no le puedes pasar no le puedes pasar todo de golpe sino que tienes que hacer las cosas con bastante más detalle,

Y esto pues al final te permite tener un control mucho más exhaustivo de lo que vas a hacer,

Eso del tema de los comandos la siguiente sería el talón de Aquiles de bash que no es ni más ni menos que jason,

Y digo que no es ni más ni menos que jason porque al final uno de los grandes problemas que tienes con,

Con con con bash es pelearte exactamente con con las estructuras con los jason con los jammel con los xml,

Y aquí tienes un problema en el caso particular de rast la gran ventaja que tienes es que todo este tipo de cosas,

Ya las puedes tratar directamente en el ejemplo que he puesto estoy utilizando por un lado en el tema de bash,

Estoy utilizando curl aparte de curl evidentemente tenemos que poner un if para verificar que el resultado que obtenemos,

Es un resultado correcto si no deberíamos dar un error de red luego tenemos que pasar la respuesta que hemos obtenido,

Por jq para obtener la ip y luego preguntarle a o verificar que la respuesta es correcta,

En el sentido de que la respuesta no está vacía y la respuesta no es un null y ya daríamos el resultado correcto,

Con lo cual como te digo tienes por un lado el comando o la llamada que haces las dos condicionales,

Y con esto pues obtendrías el resultado aquí ya vemos la primera de las grandes ventajas que te ofrece,

Rast script para este tipo de cosas la primera es que directamente vas con un crate vas a hacer la llamada,

No tienes que utilizar una herramienta externa y luego directamente ya lo conviertes en un valor de tipo json,

Y a partir de aquí lo único que tienes que hacer es extraer la ip y mostrar el valor,

¿Y por qué digo que se simplifica todo? pues de nuevo aquí viene la magia del operador interrogante,

Con el operador interrogante lo que vas a hacer es que cada vez que se produzca un error directamente lo vas a sacar por pantalla,

Tanto en el caso de que haya un problema para hacer la llamada como que la llamada te dé un error,

Que lo que te devuelva no es correcto igual que cuando hagas la conversión,

Si conviertes cuando lo conviertes si no has encontrado el campo ip te va a dar un error,

Y todo esto lo tienes en dos líneas incluso todavía podríamos resumirlo más,

Pero vamos que con dos líneas lo tienes perfectamente y es realmente interesante,

Lo siguiente y evidentemente necesario son las variables de entorno,

En el caso de las variables de entorno estamos en las mismas,

Aquí para el tema de las variables de entorno cuando tienes que utilizar variables de entorno,

Por defecto pues ahí te puedes encontrar con una sintaxis que normalmente es bastante críptica,

Es bastante extraña para el usuario normal para bueno para el usuario habitual para quiero decir,

Si ya estás acostumbrado a utilizar vas para hacer scripting en vas pues probablemente no tengas ningún tipo de problema,

Pero si no seguro que aquí te vas a encontrar más de una más de una sorpresa,

Y luego por otro lado en el caso de de rast script es realmente muy sencillo,

Porque aquí lo que haces como de costumbre es tirar de el de del estándar env,

Y luego preguntas si ha conseguido obtener el valor,

Y si no ha obtenido conseguido si no ha obtenido el valor,

Directamente utiliza por ejemplo info que es lo que yo estaba probando,

Con lo cual con esto queda muy claro quiero decir que al final es bastante verboso,

Si se le puede decir de esa manera la manera de mostrarte valga la redundancia,

La manera de devolverte el valor que necesitas,

Lo siguiente y algo habitual que hacemos son trabajar con rutas,

Es decir simplemente me refiero a trabajar con rutas a mostrarte los valores de algunas,

Por ejemplo si quieres ver o si quieres por ejemplo crear un archivo en un directorio concreto,

Por ejemplo si tienes una carpeta que se llame mi carpeta con espacios,

E intentas crearla en bus sabes perfectamente que tienes que tener un excesivo,

O mejor dicho un cuidado riguroso con las dobles comillas,

Porque si no utilizas bien las dobles comillas lo que te puedes llevar la sorpresa,

De que aquello en lugar de hacerte un directorio te hace tres o cuatro directorios,

O vete a saber lo que hace,

Por contra en el caso particular de rast script,

Pues evidentemente lo primero es que tiene en cuenta los espacios,

Porque al contrario de lo que sucede con bus,

Que todo se considera como texto,

Aquí lo has convertido ya a una ruta,

Cuando añades nuevas cosas a la ruta directamente añade la barra automáticamente,

Con lo cual todas estas ventajas las tienes incorporadas,

Digamos que en este caso es bastante más seguro,

O bastante más sencillo gestionar rutas en rast script que con simplemente bus,

Ahora nos tocaría el tema de,

Bueno realmente lo que quería hacer ahora es mostrarte como se lee un archivo grande,

Pero para esto lo que he hecho ha sido primero,

Generar un archivo,

Antes de leerlo generar un archivo de varios millones de líneas,

En concreto de dos millones de líneas,

Y tú dirás ¿por qué has generado un archivo tan grande,

Bueno pues porque quería mostrarte realmente lo rápido,

Comparado con bus,

Que es trabajar con rast script,

Para generar ese archivo lo que he hecho ha sido hacerlo en rast script,

Por un lado y también lo he hecho en python,

No lo he hecho en bus,

Simplemente por comodidad ¿vale,

Porque ya es un pelín más complejo,

Y tampoco me ha querido complicar mucho la vida,

No te creas,

Al final se trata de un script que utiliza,

Rant para generar de forma completamente aleatoria,

Las líneas y luego un command,

El create chrono para el tema de los tiempos,

Este simplemente lo he dejado un poco para que te hagas una idea de,

Cómo sería hacer lo mismo en rast que en python,

Y luego está la operación de leer archivos,

Para leer archivos,

Para leer archivos,

Estamos en las mismas,

Cuando ves el script en bus,

Dices ostras es que es súper sencillo leer miles de líneas en bus,

Y si lo comparas con rast script pues,

Tienes que importar determinadas herramientas,

Tienes que hacer determinadas operaciones,

Y puedes llegar a pensar que es un poco más complejo,

Sin embargo la cosa cambia sensiblemente cuando lo ejecutas,

Si ejecutas el leer archivos en bus,

Bus 8 leer archivos sh,

Pues te vas a dar cuenta que por lo menos tarda,

Yo quiero recordar que cuando lo ejecuté al hacer esto,

Eran unos 20 segundos más o menos,

Lo que tardaba en operar directamente con bus,

En leer esas dos millones de líneas,

Claro,

Habitualmente no te vas a enfrentar con dos millones de líneas,

O sí,

Pero claro,

Esto cuando lo ejecutas en rast script,

Lo que te das cuenta es que tengo un error,

Es que tenía que salir,

Era tarde o temprano,

Tenía que salir el error,

Ya decía yo que,

Que me faltaba aquí algo,

Es que no puede ser,

No puede ser,

No puede ser,

No puede ser,

Y ahora mismo,

For,

If,

Pues no veo donde está el error,

Así,

Abuela pluma,

No veo el error.

Y no me quiero pelear,

Ahora mismo con esto,

Porque,

Si no,

Ah bueno que he puesto bus,

Madre mía,

Madre mía,

Nada nada,

No tengo ningún error,

El error lo tengo yo,

Vale pues,

Si lo ejecutas directamente,

Pues no tarda nada,

Voy a hacerlo otra vez,

En rast script,

Para que veas,

Rast,

En,

Si,

Bueno,

No hace falta que es con 8,

A ver lo que he hecho ha sido ejecutar,

He ejecutado el script,

En rast script,

Pero con bus,

O sea he puesto bus,

Y el rast script,

Y claro,

Ha dado un error,

Si lo ejecutas directamente,

Pues lo que te dice es que no llega a tardar,

Exacto,

Ni un segundo,

Si esto mismo lo haces con bus,

Pues como te decía,

Pues son,

19 Segundos,

Y como te digo,

Bueno,

Tú puedes pensar,

Bueno pero,

¿Quién va a leer 2 millones de líneas.

Pues simplemente,

Cuando te tengas que enfrentar,

A un log,

Pues probablemente,

Te tengas que enfrentar,

No a 2 millones de líneas,

Sino a probablemente,

Muchísimas más líneas,

Claro,

Tratar con esto,

Pues efectivamente,

20 Segundos ha tardado,

Tratar con esto,

Pues no tiene mucho sentido,

Estos son las,

Generar logs,

Leerlos,

Y lo último que nos queda,

Que ya sería el colofón final,

Es el tema de los hilos,

Para esto,

Lo que he hecho ha sido,

Un script,

En,

Base,

Que lo único que hace es,

A 50 servidores,

Le pregunta,

Por una IP,

Si está viva o no,

Luego,

Posteriormente,

Lo que he hecho ha sido,

Hacerlo en paralelo,

O,

Primero,

Utilizando,

Simplemente,

El,

Ampersand,

Para hacer las llamadas,

O,

También utilizando,

La herramienta,

Paralel,

Con paralel,

Puedes hacer,

Esta operación,

Lo que pasa es que,

El problema que vas a tener,

Es que paralel,

No está instalado siempre,

En todos los servidores,

Con lo cual,

Puede tardar un poquito,

Y luego la otra opción,

También la he hecho,

Con dos opciones,

De Rast Script,

Una primera opción,

De Rast Script,

Que simplemente,

Utilizando hilos,

Simplemente,

No hace,

Nada más,

Que utilizar,

Hilos,

O sea,

Es decir,

Define,

Aquí,

Crea un hilo,

Y luego,

Al final,

Une todos los hilos,

Espera que todos los hilos,

Terminen,

Y ya está,

Va subiendo todos los hilos,

Espera que terminen,

Y ya está,

Eso sería una opción,

Que bueno,

Que también,

Es interesante,

Y luego,

La otra opción,

Es utilizando,

Un CRED,

Que se llama,

Rayon,

Que lo voy a abrir,

Aquí,

En paralelo,

Un script,

Que se llama,

Rayon,

Que realmente,

Es,

Que no lo he abierto,

Vale,

Ese,

Vale,

Vale,

El script,

Hecho,

Con,

El CRED,

Rayon,

Realmente es,

Espectacular,

Porque lo deja,

Bueno pues,

Pues no te lo puedo enseñar,

Bueno lo dejaré,

En las notas,

Del episodio,

Lo dejaré,

Ah sí,

Bueno,

Ya no sé,

Si lo tengo,

En Rayon,

Pero sí,

Sí,

El que,

Sí,

Está en Rayon,

Aquí,

Lo impresionante,

Del asunto,

Es que simplemente,

Lo que tienes que hacer,

Es escribir,

Por ejemplo,

Un array,

Con todos los servidores,

Y a partir de la array,

Simplemente,

Utilizando,

Into par,

Iter,

Y for each,

Ya hace todas las operaciones,

Que tiene que hacer,

Los pone en su,

O sea,

Los,

Crea los hilos,

Trabaja con los hilos,

Espera que los hilos,

Hayan terminado,

Lo hace todo,

Con lo cual es realmente,

Impresionante,

Bueno,

Para que te hagas una idea,

Si ejecutamos esto,

Voy a ejecutarlo,

Con time,

Y voy a ejecutar,

El de sin hilos,

¿No,

9,

El sin hilos,

Si ejecutamos,

El sin hilos,

Y nos esperamos,

A que,

Haga,

Todas las llamadas,

Yo creo recordar,

Que,

Tardaba,

Prácticamente,

Un minuto,

En hacerlo,

No voy a esperarme,

Con esto,

Para que te hagas una idea,

Luego,

Si lo ejecutamos,

Con hilos,

9,

Hilos,

Si lo ejecutamos,

Con hilos,

Pero,

En bus,

Pues aquí,

Tarda,

Dependiendo,

De cómo,

Lo hacías,

Pues tarda,

5 O 6 segundos,

Y en,

Rush script,

Pues tarda,

Más o menos,

Lo mismo,

Pero claro,

Ya has visto,

Lo sencillo,

Que es hacer,

La operación,

Aquí ha tardado,

6 Minutos,

20 Segundos,

Que no me acuerdo,

Cómo se llama,

Con paralel,

Luego está,

Con paralel,

Que más o menos,

Tarda 5 segundos,

También,

Aquí ya tarda,

Todo más o menos,

Lo mismo,

Otros 6 segundos,

Y luego nos queda,

La última opción,

Que es con rayon,

Que aquí lo único,

Es el método,

Como lo trata,

Aquí no me acuerdo,

Si este ya lo había,

Compilado,

Si no lo vuelvo a lanzar,

Porque a lo mejor,

Este no lo había compilado,

Algunos de estos,

Da error,

Simplemente,

Por el tema,

Aquí ha tardado,

11 Segundos,

Yo creo que por la compilación,

Vale,

Si ahora,

Ahora lo ha lanzado,

Rápido,

Esto es lo que te conté,

En el episodio anterior,

Y es que,

La primera vez,

Que lo lanza,

Pues tienes que pelearte,

Con el tema,

De compilarlo,

Pero una vez,

Ya está compilado,

Pues no tarda tanto,

Esto va,

A rachas,

Estuve haciendo pruebas,

Con esto de la compilación,

O mejor dicho,

Con esto de las llamadas,

Y depende mucho,

De,

Cuando lo hagas,

Como lo hagas,

Hay veces que tarda,

Me he encontrado,

En alguna ocasión,

Que tarda hasta segundos,

O sea hasta,

Quiero decir,

Menos de 5 segundos,

Y otras veces,

Que tarda más,

Sobre todo,

Son todos los que,

No responden,

Y luego también,

Está el asunto,

De que hay,

Servidores,

Que filtran,

Directamente los PIN,

Para que no respondan,

Y esto es un poco,

Lo que quería contarte,

Ya te digo que,

Se trata de un episodio,

Bastante denso,

Para contarlo,

Sobre todo,

Tipo podcast,

Pues es realmente complejo,

Pero espero que te hayas,

Llevado una idea,

Sobre todo es,

Los conceptos,

El tema de,

Lo que te han dado,

Explicando un poco,

Las opciones,

Las ventajas,

Y lo más interesante,

Es que le pegues,

Un vistazo,

A todos los ejemplos,

Que te he dejado,

En las notas,

Del episodio,

Y no solamente eso,

Sino que al final,

Te he puesto,

Una tabla comparativa,

Del manejo,

De errores,

El tema,

De que,

En el caso particular,

De manejo de errores,

Tienes que lidiar,

Con la variable,

Dólar interrogante,

Frente a,

Ras que tienes que utilizar,

El operador interrogante,

Luego el paso,

De argumentos,

La lógica,

De datos,

Las capturas,

De salida,

El trabajar,

Con jason,

Son esos conceptos,

Los que yo quería,

Intentar transmitir,

De una manera,

Lo más sencilla posible,

Pero bueno,

Ya te digo,

Que si has llegado,

Al minuto 2,

Bueno,

Ya eres un héroe,

Pero es que si estás,

Escuchando esto,

Vamos,

Te mereces,

Un,

Un altar,

Como aquel que dice,

Y nada más,

Esto es un poco,

Lo que quería contarte,

En este episodio,

Tan denso,

Espero,

Que lo hayas disfrutado,

Tanto como lo he disfrutado yo,

Por lo menos,

Preparándolo,

Haciéndolo,

Y contándotelo,

Y sobre todo,

Esperando,

A ver quién ha llegado,

Hasta el final,

Si puedes,

Ya sabes,

Una valoración,

En iVoox,

En Apple Podcast,

En Spotify,

Sobre todo,

Para este episodio,

Me vendría fantástico,

Si te gustaría,

Más episodios de estos,

No dudes en decírmelo,

Porque yo creo,

Que son complejos,

Pero bueno,

Simplemente es por tener una idea,

Recordarte que este es un podcast,

De la red de podcast,

De sospechosos habituales,

Donde puedes encontrar,

Fantásticos y maravillosos podcasts,

Puedes participar,

En esta red,

Entrando en,

Telegram,

T.me,

Barra,

Win tablet info,

Y de la misma manera,

Si quieres participar,

En el grupo,

Atareado con Linux,

Simplemente tienes que hacer eso,

Buscar,

Atareado con Linux,

En telegram,

Y allí nos vas a encontrar,

Hablando pues,

De RAS,

De BAS,

De FIS,

De Docker,

De Shell,

De todo este tipo de cosas,

Relacionadas con el mundo,

Del open source,

Y bueno,

Y si que tengo algo más que decirte,

Recordarte,

A ver,

Probablemente,

Hoy,

Hoy es lunes,

Si hoy es lunes,

Y hoy es 19,

Hoy ha salido el primer episodio,

De,

La era de las distros,

Se trata de un nuevo podcast,

Que es completamente independiente,

A este,

Es un podcast,

En el que,

En el que,

Hablamos,

Con los protagonistas,

De,

Las,

Distribuciones,

Autonómicas,

Que surgieron,

En España,

A principios,

Finales,

De los,

Bueno,

Principios de los 2000,

En ese entorno,

Y que marcaron,

Un antes y un después,

En lo que,

A la soberanía digital,

En España,

Se refiere,

Creo que es,

Una serie de,

Podcast,

Una serie de episodios,

De podcast,

Realmente,

Interesantes,

Yo,

Estoy,

Muy,

Fascinado,

Con todo lo que se cuenta,

La mayoría,

De lo que se cuenta,

Bueno,

Yo te diría,

Que el 99%,

Lo desconocía,

Por completo,

Y realmente,

Vale muchísimo,

La pena,

Que lo escuches,

Porque,

Los testimonios,

Son realmente,

Espectaculares,

Todo lo que se hizo,

Lo adelantado,

Que se llegó,

En aquel momento,

Realmente es muy espectacular,

Y poco más que decirte,

Espero que te guste,

Sinceramente,

Recordarte que la vida,

Son dos días,

Y uno ya ha pasado,

Así que disfruta,

Como si no hubiera mañana,

Y si puede ser,

Con Linux,

Y en este caso,

Con Rust's Script,

Mejor que mejor,

Un saludo,

Y nos escuchamos,

El próximo jueves,

Adiós,

¡Suscríbete al canal.

Deja una respuesta