jc, jq y gron: el tridente JSON para Linux

Vistas: 367
0:00 / 0:00
jc, jq y gron: el tridente JSON para Linux

Hoy toca hablar de tres herramientas que, sin ser nuevas, forman una combinación tan potente que yo llamo el tridente JSON de Linux. Te hablo de jc, jq y gron. Y no, no son tres amigos míos, aunque a lo mejor jc podría serlo. La historia empieza con el episodio anterior. Te conté cómo montar una automatización matutina con el nightly-runner, y en ese proceso necesitaba extraer información del sistema. Hasta ahí todo normal. Lo que pasa es que me di cuenta de que la forma tradicional de hacerlo es con awk, sed, cut y otras herramientas que, funcionan, sí, pero son frágiles. Muy frágiles. Un cambio en el orden de las columnas de ps aux y tu script se va al garete.

Además, quería pasarle esa información a un modelo de lenguaje. Y claro, un modelo de lenguaje entiende mucho mejor un JSON bien estructurado que una salida de texto plano con columnas desiguales. Así que empecé a buscar herramientas que me ayudaran a convertir la salida de comandos Linux en JSON de forma limpia y fiable. Y ahí encontré jc.

El problema de la salida en texto plano

Tradicionalmente, los comandos de Linux muestran la información en texto plano con columnas. ps aux, df -h, free, ss, systemctl… todos te devuelven tablas de texto que están pensadas para ser leídas por un humano, no por una máquina.

Para extraer información de esas tablas, los administradores de sistemas hemos usado siempre awk, sed, cut y grep. Y funciona, no te voy a engañar. Pero tiene un problema grave: si cambia el orden de las columnas, si añaden una columna nueva o si el formato varía entre versiones, tu script se rompe.

Y luego está el tema de los modelos de lenguaje. Si quieres pasarle la información de tu sistema a un modelo como Llama 3.2, lo ideal es dársela en un formato estructurado. Un JSON con campos claros, sin ambigüedades. Porque si le pasas la salida de ps aux tal cual, el modelo puede interpretar mal las columnas o confundir unos datos con otros.

jc: de texto plano a JSON

jc es la herramienta que convierte la salida de comandos Linux a JSON. Se instala con pip. No necesita permisos de root, no requiere configuración, no necesita un daemon corriendo en segundo plano. Simplemente lo instalas y empiezas a usarlo.

pip install jc

La primera vez que lo usas te cambia la perspectiva. Llevas años haciendo ps aux | awk '{print $2, $11}' y de repente haces ps aux | jc --ps | jq '.[] | {pid, command}' y todo cobra sentido. Los campos tienen nombre, no dependen de su posición en la salida, y puedes encadenar operaciones de forma limpia y predecible.

jc funciona detectando automáticamente el comando que le pasas y aplicando el parser correspondiente. Pero también puedes forzar un parser concreto si la detección automática falla. Y como te he dicho, si no hay parser para tu comando, puedes crear uno. La comunidad ha ido añadiendo parsers con el tiempo, y la lista sigue creciendo.

Y luego simplemente haces un pipe:

ps aux | jc --ps

Y ya tienes un JSON con todos los procesos, cada campo perfectamente identificado: pid, cpu, mem, rss, command, user… todo.

El funcionamiento por debajo es sencillo. jc tiene parsers específicos para cada comando. Más de 60 parsers incluidos de serie. Desde los más comunes como ps, df, free, ss, systemctl, lsblk, hasta otros más específicos como crontab, last, lsof, pip list, lsmod, date, y muchos más.

jc -a

Este comando te lista todos los parsers disponibles. Y si ninguno te sirve, puedes crear el tuyo propio. jc está escrito en Python, con licencia MIT, y acepta parsers personalizados.

La gran ventaja de jc frente a awk es que el JSON no depende del orden de las columnas. Aunque la versión de ps que tengas muestre las columnas en otro orden, jc sigue devolviendo el mismo JSON estructurado. Tu script no se rompe.

Puedes usar jc tanto con entrada estándar como con archivos:

df -h > /tmp/df.txt
jc --df /tmp/df.txt

Esto te permite guardar la salida de comandos en un momento dado y procesarla más tarde, o pasarle archivos históricos.

jq: la navaja suiza de los JSON

Si jc es el que genera los JSON, jq es el que los procesa. jq es a JSON lo que sed es a texto: el procesador por defecto. Está escrito en Go y es maduro, estable y rapidísimo.

Con jq puedes filtrar, seleccionar, ordenar, agrupar, mapear y transformar cualquier JSON. La sintaxis es potente y expresiva, aunque a veces puede resultar liosa. Pero como te contaré más adelante, para eso están los modelos de lenguaje.

La sintaxis de jq merece que le dediques un tiempo, pero no te preocupes si al principio te resulta críptica. Es normal. A mí también me pasó. Lo bueno es que puedes pedirle a cualquier modelo de lenguaje que te genere la expresión de jq que necesitas. Le explicas qué JSON tienes y qué quieres extraer, y él te devuelve el comando.

Algunos ejemplos de lo que puedes hacer combinando jc y jq:

# Procesos que más RAM consumen
ps aux | jc --ps | jq '.[] | select(.rss > 100000) | {user, command, rss}'

# Discos con más del 80% de uso
df -h | jc --df | jq '.[] | select(.use_percent | tonumber > 80)'

# Servicios que han fallado
systemctl --all | jc --systemctl | jq '.[] | select(.state == "failed")'

Todo en una sola línea. Sin awk, sin sed, sin scripts frágiles. Y con la tranquilidad de que el formato es siempre el mismo.

Los filtros de jq se pueden encadenar con pipes, igual que en la shell. Puedes seleccionar campos, filtrar por condiciones, ordenar resultados, agrupar por campos y limitar la salida. Todo en una expresión que, aunque parezca compleja al principio, sigue una lógica muy clara una vez que le coges el truco.

También puedes construir JSONs nuevos desde cero:

jc --ps | jq '{total_procesos: length, procesos_por_usuario: [group_by(.user)[] | {user: .[0].user, count: length}]}'

Este comando transforma 500 líneas de procesos en un JSON resumen con el total y el recuento por usuario. En una sola línea.

Los parsers más útiles de jc

jc incluye parsers para más de 60 comandos, pero hay algunos que vas a usar más que otros. Aquí te dejo los que a mí me han resultado más útiles:

  • --ps: procesos del sistema. Te da pid, cpu, mem, rss, command, user, time…
  • --df: discos. Filesystem, size, used, avail, use_percent, mount…
  • --free: memoria. Total, used, free, shared, buff/cache, available…
  • --ss: sockets. Netid, state, recv_q, send_q, local, peer, process…
  • --systemctl: servicios. Unit, load, active, sub, description, state…
  • --lsblk: dispositivos de bloque. Name, maj:min, rm, size, ro, type, mountpoint…
  • --ifconfig: interfaces de red. Name, flags, mtu, mac, inet, inet6…
  • --uptime: tiempo de actividad. Time, uptime, users, load_1m, load_5m, load_15m…
  • --last: últimos inicios de sesión. User, tty, from, login_at, logout_at…
  • --crontab: tareas programadas. Minute, hour, day_of_month, month, day_of_week, command…

Cada parser tiene su propia estructura de salida, pero todos siguen el mismo patrón: un array de objetos con campos claramente nombrados. Esto hace que encadenar varios comandos y procesarlos con jq sea trivial.

gron: haz greppable cualquier JSON

Y luego está gron, que para mí era un absoluto desconocido hasta que empecé a preparar este episodio. gron hace una cosa muy simple pero increíblemente útil: aplana un JSON.

¿Por qué querrías aplanar un JSON? Porque los JSONs suelen ser profundos y anidados, con objetos dentro de objetos. Si haces un curl a una API y quieres buscar un valor concreto, no puedes hacer grep porque todo el JSON está en una sola línea o en un árbol complejo.

gron convierte esto:

{"weather": {"temp": 28, "humidity": 65}, "wind": {"speed": 12}}

En esto:

json.weather.temp = 28
json.weather.humidity = 65
json.wind.speed = 12

Ahora cada valor tiene su propia línea, y puedes hacer grep de forma natural:

curl "https://wttr.in/Madrid?format=j1" | gron | grep temp

Y no solo eso. gron también hace la operación inversa. Puedes editar el JSON aplanado con sed, y luego volver a convertirlo a JSON con gron --ungron. Esto te permite modificar JSONs de forma sencilla usando herramientas de texto tradicionales.

La combinación de jc, jq y gron te cubre todo el ciclo de vida del JSON: generación (jc), procesamiento (jq), y exploración (gron).

sysreport.py: todo en uno

Con estas tres herramientas como base, he creado un script en Python que llamo sysreport.py. Lo que hace es ejecutar varios comandos del sistema, convertir sus salidas a JSON con jc, y agruparlo todo en un único archivo JSON estructurado.

python3 sysreport.py

Esto genera /tmp/sysreport.json con toda la información del sistema: procesos, discos, memoria, servicios, puertos, usuarios, tiempo de actividad… TODO.

Luego puedes consultar ese JSON con jq:

cat /tmp/sysreport.json | jq '.memoria'

O pasárselo directamente a un modelo de lenguaje para que lo analice.

sysreport.py
#!/usr/bin/env python3
"""
sysreport.py — Genera un reporte completo del sistema en JSON.
Usa jc para convertir la salida de comandos del sistema a JSON
estructurado. Ideal para diagnosticar, auditar o pasar a una IA.

Uso:
  python3 sysreport.py                    # Guarda en /tmp/sysreport.json
  python3 sysreport.py --stdout           # Imprime por stdout
  python3 sysreport.py --compact           # Sin pretty-print
  python3 sysreport.py --only discos       # Solo una sección

Dependencias:
  - Python 3.10+
  - jc (pip install jc)
  - jq (sudo apt install jq)
  - Los comandos del sistema: ps, df, systemctl, ss, free, uptime
"""

import argparse
import json
import subprocess
import sys
from datetime import datetime


# ─── Secciones del reporte ────────────────────────────────────────────────────

SECCIONES = {
    "procesos": (["ps", "aux"], "ps"),
    "discos": (["df", "-h"], "df"),
    "servicios": (["systemctl", "list-units", "--no-legend"], "systemctl"),
    "puertos": (["ss", "-tlnp"], "ss"),
    "memoria": (["free", "-h"], "free"),
    "uptime": (["uptime"], "uptime"),
}


def ejecutar_jc(comando: list, parser: str) -> list | dict:
    """Ejecuta un comando y lo parsea con jc."""
    try:
        out = subprocess.run(comando, capture_output=True, text=True, timeout=10)
        if out.returncode != 0:
            return {"error": f"Comando falló: {' '.join(comando)}"}
        # Parsear con jc
        jc_out = subprocess.run(
            ["jc", f"--{parser}"],
            input=out.stdout,
            capture_output=True,
            text=True,
            timeout=10,
        )
        if jc_out.returncode != 0:
            return {"error": f"jc falló para {parser}: {jc_out.stderr[:200]}"}
        return json.loads(jc_out.stdout)
    except subprocess.TimeoutExpired:
        return {"error": f"Timeout ejecutando {' '.join(comando)}"}
    except json.JSONDecodeError as e:
        return {"error": f"JSON inválido de jc --{parser}: {e}"}
    except FileNotFoundError:
        return {"error": f"jc no encontrado. Instala: pip install jc"}


def generar_reporte(secciones: list[str] | None = None) -> dict:
    """Genera el reporte del sistema."""
    incluir = secciones if secciones else list(SECCIONES.keys())

    reporte = {
        "fecha": datetime.now().isoformat(),
        "hostname": subprocess.run(
            ["hostname"], capture_output=True, text=True, timeout=5
        ).stdout.strip(),
    }

    for seccion in incluir:
        if seccion in SECCIONES:
            comando, parser = SECCIONES[seccion]
            reporte[seccion] = ejecutar_jc(comando, parser)

    return reporte


# ─── Main ─────────────────────────────────────────────────────────────────────

def main():
    parser = argparse.ArgumentParser(
        description="sysreport: reporte del sistema en JSON usando jc",
        formatter_class=argparse.RawDescriptionHelpFormatter,
        epilog="""\
Ejemplos:
  python3 sysreport.py                        # Guarda en /tmp/sysreport.json
  python3 sysreport.py --stdout                # Imprime por stdout
  python3 sysreport.py --only procesos discos  # Solo procesos y discos
  python3 sysreport.py --stdout | jq '.discos' # Filtrar con jq
        """,
    )
    parser.add_argument("--stdout", action="store_true", help="Imprimir por stdout en vez de guardar")
    parser.add_argument("--compact", action="store_true", help="Sin pretty-print (más pequeño)")
    parser.add_argument("--only", nargs="+", choices=list(SECCIONES.keys()),
                        help=f"Solo estas secciones: {', '.join(SECCIONES.keys())}")

    args = parser.parse_args()

    print("📡 Generando reporte del sistema...", file=sys.stderr)
    reporte = generar_reporte(args.only)

    indent = None if args.compact else 2

    if args.stdout:
        print(json.dumps(reporte, indent=indent, ensure_ascii=False))
    else:
        output_path = "/tmp/sysreport.json"
        with open(output_path, "w") as f:
            json.dump(reporte, f, indent=indent, ensure_ascii=False)
        print(f"✅ Reporte guardado en {output_path}", file=sys.stderr)
        print(f"📦 Tamaño: {len(json.dumps(reporte))} caracteres", file=sys.stderr)
        print(f"   Secciones: {', '.join(reporte.keys())}", file=sys.stderr)

        # Mostrar resumen rápido
        errores = [k for k, v in reporte.items() if isinstance(v, dict) and "error" in v]
        if errores:
            print(f"⚠️  Errores en: {', '.join(errores)}", file=sys.stderr)

        # Contar elementos por sección
        for k, v in reporte.items():
            if isinstance(v, list):
                print(f"   {k}: {len(v)} elementos", file=sys.stderr)


if __name__ == "__main__":
    main()

Preguntando al sistema en lenguaje natural

Y aquí llega lo bueno. El script sysreport.py incluye un modo interactivo donde puedes hacer preguntas en lenguaje natural sobre el estado de tu sistema.

python3 sysreport.py --ask "¿Qué procesos consumen más RAM?"

Lo que hace por debajo es bien sencillo. Carga el JSON del sistema, lo mete en un prompt junto con la pregunta, y se lo envía a Ollama con Llama 3.2. El modelo analiza los datos y responde en lenguaje natural.

El proceso que más RAM consume es OBS Studio con un 32.7%. Le sigue Firefox con un 15.2%. El resto de procesos están dentro de lo normal.

O puedes preguntarle:

python3 sysreport.py --ask "¿Hay algún disco lleno o servicios caídos?"

Y te responde con un diagnóstico completo. Todo en local, sin enviar datos a ningún servidor externo.

Puedes hacer tantas preguntas como quieras. Una vez que el modelo está cargado en memoria, las respuestas son prácticamente instantáneas. En el episodio hago una demo en vivo donde primero le pregunto por los procesos que más RAM consumen, luego por los servicios caídos y luego le pido un resumen general del sistema. Todo en cuestión de segundos.

El prompt del sistema es clave. Le digo que es un administrador de sistemas y que debe analizar el JSON y responder en lenguaje natural. Con eso basta. No necesita instrucciones más complejas porque el modelo entiende el contexto.

El corazón del script es una llamada a la API de Ollama:

import requests, json

datos = json.load(open("/tmp/sysreport.json"))
pregunta = "¿Qué procesos consumen más RAM?"

respuesta = requests.post("http://localhost:11434/api/chat", json={
    "model": "llama3.2:3b",
    "messages": [
        {"role": "system", "content": "Eres un administrador de sistemas. Analiza el JSON y responde en lenguaje natural."},
        {"role": "user", "content": f"Datos del sistema: {json.dumps(datos)}\n\n{pregunta}"}
    ]
})
print(respuesta.json()["message"]["content"])

Así de sencillo. Sin dependencias externas, sin APIs de pago, sin complicaciones.

Monitorización con watch

Cómo aprender jq sin volverte loco

Si nunca has usado jq, la sintaxis te va a parecer críptica. Es normal. A mí también me pasó. La clave es empezar con operaciones simples e ir subiendo la complejidad poco a poco.

Empieza por jq '.' que solo formatea el JSON. Luego prueba jq '.[]' para iterar sobre arrays. Luego jq '.[] | {campo1, campo2}' para seleccionar campos. Y luego añade filtros con select(.campo > valor). En cuestión de horas, estarás haciendo consultas complejas como si nada.

Y si te atascas, recuerda que puedes pedirle a cualquier modelo de lenguaje que te genere la expresión de jq. Le pasas un ejemplo del JSON y le dices lo que quieres extraer, y él te devuelve el comando.

sysreport.py en acción

En el episodio hago una demo en directo. Lanzo el script, que recoge información de ps, df, free, ss y systemctl, y genera un JSON con todo. Luego le pregunto qué proceso consume más RAM. La respuesta es OBS Studio con un 32.7%, que tiene toda la lógica porque estoy grabando el episodio.

Luego le pregunto por servicios caídos y aunque el modelo no encuentra ninguno, el sistema responde con un diagnóstico completo. Y finalmente le pido un resumen general del estado del sistema. En todos los casos, la respuesta es rápida, precisa y en lenguaje natural.

La segunda pregunta es mucho más rápida que la primera porque el modelo ya está cargado en memoria. Este detalle es importante si vas a usar el script de forma interactiva.

sysreport.py como API

Otra opción interesante es usar sysreport.py como una API local. Puedes lanzar el servidor y hacer consultas HTTP:

python3 sysreport.py --serve

Esto levanta un servidor en localhost:8000 donde puedes hacer consultas en lenguaje natural mediante POST. Perfecto para usarlo desde otros scripts, desde el móvil o desde cualquier aplicación que necesite información del sistema en lenguaje natural.

Monitorización con watch

watch -n 5 "jc --ps | jq '[.[] | select(.rss > 100000) | {command, rss}]'"

Esto actualiza cada 5 segundos la lista de procesos que consumen más de 100 MB de RAM. O puedes usar el sysreport con notify-send para recibir alertas en el escritorio:

python3 sysreport.py --check-disk --notify

Si algún disco supera el 80% de ocupación, te salta una notificación en el escritorio.

Ventajas de este enfoque

Todo esto tiene varias ventajas frente a las soluciones tradicionales. La primera es que es completamente local. No envías información de tu sistema a ningún servidor externo. La segunda es que no cuesta dinero. Todo corre en tu máquina, con tu modelo de lenguaje, sin APIs de pago. La tercera es que es modular. jc, jq y gron son herramientas independientes que puedes usar por separado o combinadas.

Y luego está el factor de la fiabilidad. Con awk, un cambio en la salida de ps aux rompe tu script. Con jc, el JSON es siempre el mismo. Da igual si actualizas el sistema, si cambias de distribución o si el comando modifica su formato de salida. jc se encarga de normalizarlo todo a JSON. Da igual la versión del comando, da igual la distribución, da igual el orden de las columnas. El JSON estructurado es predecible.

sysreport: integración con el nightly-runner

Si te viste el episodio 815, recordarás que el nightly-runner necesitaba un módulo para extraer información del sistema. Pues este es exactamente ese módulo. sysreport.py genera el JSON que el nightly-runner usa para incluir el estado del sistema en el resumen matutino.

La integración es directa. En el nightly-runner añades una llamada a sysreport:

import subprocess, json
subprocess.run(["python3", "sysreport.py"])
with open("/tmp/sysreport.json") as f:
    datos_sistema = json.load(f)

Y esos datos se pasan al prompt de Llama 3.2 junto con el tiempo, las noticias y las zapatillas. El resultado es un resumen matutino que también te dice si el disco se está llenando o si hay algún proceso que se está comiendo toda la RAM.

Más allá del sistema

Aunque en este episodio me he centrado en la información del sistema, jc va mucho más allá. Puedes convertir a JSON desde consultas DNS hasta listados de paquetes de apt o pacman, pasando por archivos de configuración, crontabs, logs de sistema y mucho más.

Y jq, por supuesto, te sirve para cualquier JSON, venga de donde venga. APIs web, archivos de configuración, exportaciones de datos… es una herramienta universal.

gron es más específico, pero cuando necesitas explorar un JSON profundo o hacer búsquedas rápidas, no hay nada más rápido que un grep sobre un JSON aplanado.

Casos de uso reales

Para que veas el potencial de esta combinación, te dejo algunos casos de uso reales que he ido descubriendo mientras trasteaba con estas herramientas.

El primero es la monitorización de recursos. Con un alias en tu shell, puedes tener en una sola línea el estado de tu sistema:

alias sysinfo='echo "=== PROCESOS ===" && ps aux | jc --ps | jq "length" && echo "=== DISCOS ===" && df -h | jc --df | jq ".[] | {mount, use_percent}" && echo "=== MEMORIA ===" && free | jc --free'

El segundo es la detección de anomalías. Puedes comparar el estado actual con el de ayer y detectar cambios:

jc --ps > /tmp/procesos_hoy.json
diff <(cat /tmp/procesos_ayer.json | jq -c '.[] | {pid, command, rss}') <(cat /tmp/procesos_hoy.json | jq -c '.[] | {pid, command, rss}')

El tercero es la generación de informes. Con un script sencillo puedes generar un HTML con el estado del sistema:

echo "<html><body><h1>Informe del sistema</h1><pre>$(jc --ps | jq .)</pre></body></html>" > informe.html

Son ideas sencillas, pero te dan una idea de hasta dónde puedes llegar con estas tres herramientas combinadas.

Cierre

El tridente JSON no es una solución mágica, pero sí es una forma mucho más elegante y fiable de trabajar con información del sistema en Linux. Si hasta ahora estabas usando awk para todo, te animo a que pruebes jc. La primera vez que hagas ps aux | jc --ps | jq . y veas el JSON estructurado, entenderás de qué te hablo.

Si te animas a probar estas herramientas, empieza por lo básico. Instala jc y haz ps aux | jc --ps | jq .. Luego prueba con df, con free, con ss. Cuando te sientas cómodo, añade gron al repertorio. Y cuando domines los tres, el sysreport.py te va a parecer la consecuencia natural de todo lo aprendido.

Los scripts sysreport.py y los ejemplos de este episodio los dejaré en las notas para que puedas trastear con ellos. Y si se te ocurren más usos para esta combinación, ya sabes dónde encontrarme. En el grupo de Telegram de atareao con Linux siempre estamos dándole vueltas a este tipo de herramientas.

La combinación de jc, jq y gron te da un control sobre la información de tu sistema que con las herramientas tradicionales simplemente no tenías. Y cuando le añades un modelo de lenguaje para que interprete los datos, el resultado es una forma completamente nueva de interactuar con Linux.

Espero que te haya gustado el episodio, que lo hayas disfrutado y que le saques partido a estas herramientas. La vida son dos días y uno ya ha pasado, así que mejor tener herramientas que te hagan el trabajo más fácil.


Más información

Ver el vídeo de este episodio
Transcripción

Hola soy lorenzo y esto es atareado con Linux episodio número 816 en este episodio te voy,

A hablar sobre tres herramientas jc jq y gron y no te penses que son tres amigos míos jc bueno,

A lo mejor jc pero bueno los otros dos jq y gron seguro que no a lo mejor no te suenan de nada,

Aunque yo pienso que jq seguramente sí jq seguro que lo has utilizado en alguna ocasión si utilizas,

La terminal para trabajar con archivos json porque es una herramienta fantástica que te permite,

Operar con ellos para extraer cualquier cosa que te puedas imaginar realmente es una herramienta,

Espectacular sin embargo hoy te traigo dos herramientas que probablemente tú no conozcas,

Que son jc y gron y te digo que probablemente no las conozcas porque hasta hace poco yo tampoco las,

Utiliza las utilizaba y todo esto ha sido a raíz de buscar cómo extraer toda la información de mi,

Sistema operativo para los episodios anteriores es decir para contarme exactamente cómo está mi,

Sistema operativo funcionando y para conocer cómo está mi sistema operativo simplemente se trata de,

Preguntar a herramientas que normalmente en Linux ya están instaladas pues normalmente tienen está,

Instalado free o psps menos menos aux o cualquier tipo de estas herramientas que utilizamos habitualmente,

Para conocer el estado de nuestro sistema htop las que tú conoces habitualmente la cuestión es que,

Con esas pues pasárselas a tu modelo de lenguaje probablemente no sea lo más eficiente seguramente,

Extraiga la misma información pero como bien sabes estamos en aquella lucha por.

Optimizar el uso de tokens y no solamente optimizar el uso de tokens sino por darle exactamente la información,

Que necesita para que ese modelo de lenguaje no empiece a divagar no empieza a inventarse cosas así que en este episodio,

Complementando un poco el episodio anterior te traigo estas tres herramientas que vamos a utilizar para extraer,

Toda la información necesaria a tu sistema operativo.

Así que vamos directos al turrón te voy a hablar sobre jc jq y gron y.

Quiero que hagamos una reflexión a día de hoy tú todavía seguro que si trabajas con la terminal si eres un,

Linuxero tradicional si eres de aquellos que utilizan a wk para prácticamente todo seguro que utilizas ps,

Aux barra wk,

Dollar 2 para extraer información pero planteatelo en serio en serio en 2026 todavía tenemos que estar haciendo esto,

Y no solamente esto sino que hay otras herramientas como psdf existente tl ss que toda la información te la dan en texto plano no te dan información estructurada y como no te dan información estructurada tienes que,

Y tú quieres pasársela a tu modelo de lenguaje,

Lo más estructurado posible para precisamente lo que te he dicho anteriormente para que no invente,

Pues tienes que echar mano de herramientas como,

Awk,

Set cat,

Que te permitan convertir esa información,

La información que te devuelve ps en una información estructurada,

Sin embargo todo esto,

Funciona,

Quiero decir awk set cat funciona pero es una manera bastante frágil de extraer información,

Simplemente con que cambie el orden de las columnas tu script se va a romper,

Y si quieres preguntarle a tu modelo de lenguaje como te digo si le puedes dar toda esa información pero,

Probablemente termine liando las cosas,

Así que la solución para todo esto es utilizar herramientas como jc,

Que te permite convertir cualquier salida de terminal a un json,

O gron que lo que te permite es conseguir que un json sea grepeable,

No sé si existe este verbo,

Bueno no sé si existe seguro,

Pero básicamente se trata de que como bien sabes en un archivo json no puedes utilizar un grep,

Y con gron vas a conseguir poder hacerlo,

Con esto vas a obtener la información estructurada para que tu modelo de lenguaje para oyama,

Lo pueda entender,

Así que vamos a o te voy a hablar sobre estas tres herramientas jc,

Que básicamente lo que consigue es que cualquier herramienta de las que utilizas habitualmente la,

Convierta en un json jq que es como bien sabes la navaja suiza de los json y gron que te va a permitir trabajar sobre json,

Vamos a ver unos casos reales en los que vamos a extraer información de tu sistema operativo,

Y luego se lo vamos a pasar a tu modelo de lenguaje a través de oyama directamente con un script en python que te va a permitir interaccionar con él,

Empiezo por el principio con jc y es que jc es esa herramienta que probablemente no conocías y no es ni más ni menos que un es un script en python,

Bueno una herramienta en python que te permite convertir la salida de determinadas instrucciones de determinadas herramientas en comandos o sea de comando a json,

Es decir lo que te permite es pasar de la salida de un ps o de un df o de un systemctl en un archivo json estructurado simplemente con un pipe,

Es decir puedes hacer un ps aux pipe jc menos menos ps y esto ya se va a convertir en un json,

Cómo funciona por debajo esto bueno pues por debajo jc lo que tiene son parsers son parsers que ya vienen preparados para las funciones,

Para las funciones como ps como df o como hasta 60 parsers que tiene incluidos se trata de como te decía anteriormente una herramienta que está implementada en python,

Que estaba liberada bajo licencia mit y que además tiene la gran ventaja que te permite añadir tus propios parsers,

Y no solamente funciona sobre la entrada estándar sino que también lo puedes hacer funcionar sobre archivos ya existentes,

Perdón de manera,

Que,

Puedes en un momento determinado estar extrayendo información guardando determinados archivos y cuando se la quieres pasar a oyama,

Lo que puedes hacer es convertirla en todo esto en,

Información estructurada,

O sea en un json,

Esos json,

Manipularlos con j,

Con jq,

Para obtener por ejemplo el diferencial de dos campos determinados,

Y con esto,

Simplemente al pasárselo a tu,

A oyama ya te diría,

Pues por ejemplo la memoria ram la tenías en,

16 Gigas libres y ahora la tienes en,

Dos gigas libres por ejemplo para hacer ese tipo de operaciones,

En el uso de,

De jc es brutal o sea simplemente,

Con,

Con awk,

Lo que,

Partes,

Es de o sea si partes de ps aux y le pasas a wk,

Pues lo vas a tener bastante complicado vas a tener que estar ahí investigando cómo sacar,

Determinados campos y sin embargo con ps aux se la pasas a jc,

Indicándole que le pasas información de,

Ps ya puedes extraer los campos de una manera mucho más,

Clara,

Y es que,

El json no depende del orden de las columnas,

Si ps cambia de salida tu script va a seguir funcionando,

Así,

Jc tiene distintos parsers,

Como te decía hasta 60 parsers pero los más normales y los que más,

Habitualmente vas a utilizar son los de ps df system ctl,

Ss free ls du ip todos esos,

Los puedes pasar de una manera,

O sea son parsers habituales y son los que,

Habitualmente vas a utilizar,

Pero no solamente es esto también tienes otros parsers como para,

Parsear la información de tus crontab de los módulos del kernel de los discos,

De la fecha y hora del sistema los últimos logins,

Información de apt información de pacman consultas dns,

Todo eso con jc lo puedes trabajar y lo puedes exprimir,

Jc entiende cron, last, enf, pip list,

Entiende prácticamente cualquier cosa que te puedas echar a la cara,

Y como te decía anteriormente,

Si no lo entiende,

Tú le puedes crear el parser que tú consideres,

Como te digo no solamente te permite,

Utilizar desde entrada estándar,

Sino que además lo puedes coger de un determinado fichero,

Y esto básicamente es lo que es jc,

Como ves es una herramienta brutal para estructurar la información que necesitas,

Pasarle directamente a tu modelo de lenguaje o a lo que tú consideres,

Yo te estoy hablando aquí de modelos de lenguaje porque en los últimos episodios,

Estamos tratando todo esto de la inteligencia artificial y todo esto,

Y estamos dándole una vuelta a todo lo que son los scripts,

Y las posibilidades que se pueden hacer en el mundo Linux,

Pero evidentemente jc es una herramienta que puedes utilizar en cualquier cuestión,

La siguiente es jq jq es yo diría que una de las herramientas estándar,

Sino la más conocida para el scripting a la hora de trabajar con json,

Podemos decir sin lugar a dudas sin lugar a equivocarnos,

Que jq es a json lo mismo que set es a texto,

Ese el procesador por defecto para archivos json,

Se trata de un archivo que es un binario que te permite realizar filtros mapas,

Selects agrupaciones sobre archivos json,

Utiliza una entrada o sea utiliza la entrada estándar del archivo json,

Y te devuelve por la salida estándar un json estructurado,

O un json transformado o lo que tú consideres,

Y se trata de una herramienta que es madura estable y muy rápida,

Creo recordar que está implementada en go,

Y que funciona la verdad es que funciona,

Fantásticamente bien,

De lo más habitual a la hora de trabajar con un,

Con jq es por ejemplo hacer,

Imprimir una salida,

Lo que se dice un pretty print,

Para que salga bonito,

Que es un punto jq punto,

Lo que hace es imprimirte lo bonito,

Si lo que vas a trabajar es sobre un array de elementos,

Con jq punto,

Corchete corchete,

Te permite iterar sobre la array,

También te permite seleccionar,

O filtrar determinados,

Te permite ordenar,

Te permite agrupar,

En fin te permite hacer todo tipo de operaciones,

Sobre archivos jq,

Por ejemplo encaderando ps aux con jc y con jq,

Podrías obtener información sobre,

Qué procesos están consumiendo más ram,

O por ejemplo haciéndolo con systemctl,

Qué servicios han fallado,

O en el caso de hacerlo sobre edf,

Le podrías preguntar,

Qué discos están prácticamente llenos,

O cuántos procesos ha lanzado tu usuario,

O cuántos servicios están en qué estado,

O también conocer cuál es el puerto más habitual,

O más utilizado,

Incluso también puedes construir un json nuevo,

Desde el propio sistema,

Básicamente esto sería una sola línea de jq,

Que transforma 500 líneas de proceso,

En un json completamente estructurado,

Que te da un resumen de una manera súper sencilla,

Bueno,

También te tengo que decir que,

Trabajar con jq puede llegar a ser bastante lioso,

Pero de nuevo,

Volvemos a el maravilloso mundo,

De los modelos de lenguaje,

O de los servicios como gemini,

Hgpt o cualquiera de estos,

Donde le puedes pasar directamente,

Un ejemplo de tu,

Del archivo json que tienes que procesar,

Y utilizando jq serías capaz,

O le puedes decir que te dé,

El comando,

O los argumentos necesarios,

Para extraer las piezas que tú consideres,

Y esto es un poco lo que quería hablarte sobre jq,

Y ahora viene el siguiente,

Que es gron,

Gron yo creo que tiene que ser,

O por lo menos para mí hasta ahora,

Era el mal desconocido,

Y lo único que hace,

O la herramienta lo que hace es,

Aplanar un json,

Y es que seguro que en un momento determinado,

Has echado un curl contra una llamada,

O contra una api,

Y luego has querido hacer un grep sobre el resultado,

Porque simplemente querías saber,

La temperatura a las 6 de la tarde,

Y te has dado cuenta que no te vale,

No te vale hacerle un j,

O no te vale hacerle un grep,

Porque lo que te devuelve es un,

Un archivo,

O mejor dicho,

Una línea con el resultado,

Completamente plano,

Si esto se lo pasas a jq,

El problema que vas a tener,

Es que lo que vas a tener,

Es un listado de clave valor,

Pero ordenada según el json,

Que tengas,

Sin embargo con curl,

Lo que hace es aplanarte el json,

Es decir,

En lugar de tener,

Un json anidado,

Lo que tienes son líneas planas,

Por cada uno de los valores,

Vas a tener,

Una sola línea,

De esta manera,

Si por cada uno de los valores,

Solamente tienes una línea,

Hacer un grep,

Es realmente sencillo,

Simplemente le tienes que decir,

El valor por el que quieres,

Hacer ese grep,

Y es el valor que vas a obtener,

Y no solamente esto,

No solamente te permite,

Aplanar un json,

Sino que también te permite,

La opción,

O la herramienta inversa,

Es decir,

Te permite a partir,

De un json aplanado,

O tener el json,

Construido,

Con esta herramienta,

Puedes,

Te permite buscar,

Directamente,

Con gron,

De una manera muy sencilla,

O también,

Podrías hacerlo,

Con jq,

Podría,

En fin,

Tienes,

Una gran cantidad,

De opciones,

Pero ya has visto,

Que hemos,

Tenemos de nuevo,

Un tridente de herramientas,

Como son,

Jc,

Jq,

Y gron,

Que nos permiten,

Trabajar con archivos json,

O trabajar con información,

Estructurada,

Para según,

La operación,

Que queramos hacer,

Obtener exactamente,

Los resultados,

Que buscamos,

Incluso,

Con esta combinación,

Puedes llegar,

A modificar,

Los json,

Para obtener,

O para,

Entregar,

Un resultado,

Completamente distinto,

Al original,

No solamente esto,

Sino que además,

Con toda esta combinación,

La puedes,

Juntar con watch,

Para monitorizar,

Por ejemplo,

Puertos cada 5 segundos,

O procesos de usuario,

Todo esto lo puedes hacer,

Bueno,

A partir de aquí,

Bueno pues a partir de aquí,

De nuevo,

Yo lo que he montado,

Es un script en python,

Que se llama,

Sysreport,

Que lo que hace,

Es realizar,

Consultas rápidas,

Sobre,

Tu sistema,

Básicamente,

El objetivo es,

El script,

Crea un json,

Con toda la información,

De tu sistema,

Y luego tú,

Le puedes ir preguntando,

A ese json,

Determinadas cuestiones,

Es así de sencillo,

Es decir,

Yo ahora,

Si me voy a mi,

Ejecuto,

Python,

Sysreport,

Y lo que me genera,

Es ese,

Report del sistema,

Que yo lo tengo ahora,

En,

En tmp,

Sysreport,

Punto json,

Si yo hago,

Un tmp,

Un cat,

Del sysreport,

Punto json,

Sobre jq,

Pues ya tengo,

Toda la información,

Que,

De mi sistema operativo,

Todos los procesos,

Que están funcionando,

Información sobre,

Por ejemplo,

Jc,

Falloso,

Por ss,

Bueno,

Información de la memoria,

Informa,

Todo tipo de información,

Y esto es,

Una de las opciones,

Que tienes,

Para luego trabajar,

Con ello,

Directamente,

Al final,

Se trata de algo,

Muy sencillo,

Que te va a permitir,

Sin instalar,

Htop,

Ni btop,

Ni net data,

Ni data,

Ni nada de nada,

Con estas herramientas,

Un monitor,

Que incluso te puede,

Advertir,

Mediante,

Notify send,

El estado,

De tu sistema,

Por ejemplo,

Si hay algún disco,

Que está lleno,

O que se va a llenar,

O que está por encima,

De un límite,

Que tú le marques,

O que te informe,

De si tienes,

Un sistema caído,

O lo que tú quieras,

Al final,

Pues,

Por ejemplo,

Podríamos hacer,

Que te informe,

Sobre la situación,

De los contenedores,

Del sistema,

O cualquier otra cosa,

Bueno,

Y llegados a este punto,

Claro,

Hasta ahora,

Hemos extraído,

Toda la información,

Pero como podemos,

Esto pasárselo,

A nuestro modelo,

Pues simplemente,

Una vez ya tenemos,

Jc, jq y gron,

Combinados,

El siguiente paso,

Es pasárselo,

A oyama,

Bueno,

O al modelo de lenguaje,

Que tú quieras,

Para que analice,

La información,

Que tú le has transmitido,

Y que te indique,

El estado de tu sistema,

Por ejemplo,

Una vez,

Evaluado,

Toda la información,

Que le has suministrado,

Que te diga,

Tu sistema,

Está perfectamente,

Pero que sepas,

Que Firefox,

Se está comiendo,

3 Gigas de RAM,

Igual que te digo,

Esto,

Lo que puedes hacer,

Es preguntarle,

Por ejemplo,

Le puedes preguntar,

Directamente,

Python,

Este es otro,

De los scripts,

Que he preparado,

Voy a hacer,

Python,

Sys,

Ask.py,

Le puedo decir,

Que,

Qué procesos.

Consumen.

Más RAM,

De nuevo,

De nuevo,

Ahora está recogiendo,

Información del sistema,

Los procesos,

La consulta,

De nuevo,

Y como creo que te conté,

En el episodio anterior,

O en el anterior,

Del anterior,

Todo esto se lo estoy pasando,

A un modelo bastante ligero,

A llama 3.2,

De manera que,

Al final,

Lo puedes ejecutar,

Directamente,

Sobre CPU,

Yo lo estoy ejecutando,

Con oyama,

Ahora mismo,

Está tardando un poco más,

Porque tiene que cargar,

El modelo de,

Llama 3.2,

Lo tiene que cargar,

En la GPU,

Pero si no,

Sería relativamente,

Rápido,

Yo ahora mismo,

Podría hacer,

Un nv,

Nv top,

Vemos que ha cargado,

El modelo,

El llama 3.2,

No sé si ha cargado,

Alguno más,

Y ahora está procesándolo,

Ahora,

Le preguntaré,

Alguna cosa más,

Para que veas,

Que en los siguientes,

Iteraciones,

Va mucho más rápida,

Porque ya no tiene que cargar,

Ese modelo de lenguaje,

No lo tiene que cargar,

Directamente,

En la GPU,

Bueno,

Ya me ha dado la respuesta,

Le he puesto,

No solamente,

Que me lo ponga,

Por pantalla,

Sino que me haga,

Un notify send,

Para ver,

Un cuadrito de mensaje,

Y me dice,

El proceso que consume,

Más RAM,

Es el de OBS,

Con un consumo,

De 32,7%,

Esto es lógico,

Estoy grabando,

El vídeo,

Que ahora mismo,

Es lo que más consume,

Memoria,

Si ahora,

Le preguntara,

Cualquier otra cosa,

Como por ejemplo,

En vez de esto,

Que servicios,

Hay caídos,

Ahora debería de ser,

Mucho más rápido,

Porque como te digo,

El modelo de lenguaje,

Ya está cargado,

Y no tiene que,

Cargarlo nuevamente,

Bueno,

Pues ya lo había,

Descargado,

El fenómeno,

Esto,

El tiempo de carga,

Y descarga,

Bueno,

No,

No,

No,

No lo ha descargado,

Venga ya,

Vale,

Ya ha respondido,

Es mucho más rápido,

Hasta donde llega,

Mi conocimiento,

No tengo información,

Sobre servicios,

Caídos específicos,

El sistema,

De Arlinux,

Que estás describiendo,

Sin embargo,

Puedo decirte,

Que los servicios,

Caídos,

Pueden estar relacionados,

Con aplicaciones,

Bueno,

Salí ahí,

Y te cuenta,

Tal,

También le podemos,

Hacer,

Otro,

Que sea,

Haz,

Un resumen,

De la,

Situación,

Del sistema,

Y ahora,

Nos va a decir,

Exactamente,

Cómo se encuentra,

El sistema,

De nuevo,

Es relativamente,

Rápido,

Simplemente,

Ha obtenido,

Toda la información,

Necesaria,

Una vez,

Obtenida la información,

Ya está,

El sistema,

Arlinux,

Está funcionando,

Correctamente,

Todos los servicios,

Se ejecutan,

Según lo esperado,

Hay suficiente,

Memoria,

Tal,

Todo,

El lenguaje natural,

No es el rollo,

Este que,

De vez en cuando,

Te encuentras,

Con que te dice,

Tu memoria,

Está,

Tanto,

No,

Aquí no hay nada,

Aquí él te habla,

En lenguaje humano,

Completamente,

Sin ningún tipo,

De,

Problema,

De nada,

Ni nada,

No te tienes que calentar,

La cabeza,

En saber si es mucho,

O es poco,

De eso ya se encarga,

El sistema,

Que has montado,

Y bueno,

Qué es lo que hay,

En el corazón,

Del script,

Bueno,

En el corazón,

De este script,

Es muy sencillo,

Simplemente,

Tienes,

Un archivo,

Json,

Donde le vas a,

Meter toda la información,

Correspondiente,

A los procesos,

A los discos,

Al servicio,

A la memoria,

Le vas a preguntar,

La pregunta que la hayas,

Formulado,

Esta viene,

De python,

Y luego,

Esto le vas a hacer,

Un post,

Al servicio,

De llama,

Yo lo tengo puesto así,

Porque lo tengo levantado,

En un contenedor Docker,

Con lo cual,

De esta manera,

Relativamente sencilla,

Y lo único,

Que tienes que hacer,

Es,

Hacer una llamada,

Del tipo,

Apichat,

Pasándole,

El rol,

Del sistema,

Diciéndole,

Que es un,

Administrador,

De sistema,

Donde analiza,

El archivo,

Json,

Y responde,

En lenguaje,

Natural,

Luego le pasas,

Un contenido,

Con todos los datos,

Que tú quieres,

Y una pregunta,

Ya está,

Así de sencillo,

Sería,

Tu sistema,

Y luego esto,

Pues le puedes preguntar,

Cualquier cosa,

Lo que tú necesites,

De nuevo,

Esto es un poco,

Parecido,

A lo que vimos,

En el episodio,

Anterior,

Simplemente,

Has creado,

De un script,

No estás utilizando,

A Hermes,

Sino que directamente,

Estás utilizando,

Tu modelo,

De lenguaje,

Con lo cual,

Si con Hermes,

No podías hacer,

Todo esto,

En el caso,

De,

De este servicio,

Sí que lo vas a poder hacer,

Porque,

Tanto el contexto,

Como las herramientas,

Como,

Ya ahí no existe,

Directamente,

Le estás preguntando,

Le estás formulando,

Y le estás dando,

Los datos concretos,

Que él tiene que evaluar,

Para darte la información,

Y nada más,

Esto es un poco,

Lo que quería contarte,

En este episodio,

Simplemente,

Una herramienta,

O un trío,

De herramientas,

De nuevo,

Un tridente de herramientas,

Como son,

JC, Jquik,

Y Gron,

Que te permiten,

Trabajar,

Con distintas herramientas,

Para obtener,

Archivos estructurados,

En formato JSON,

Y poder pasárselos,

Fácilmente,

A tu,

Modelo de lenguaje,

Para que,

Analice,

O para que te dé,

Información,

Concreta,

Sobre lo que tú,

Consideres,

De nuevo,

Como estás utilizando,

Un modelo de lenguaje,

Relativamente pequeño,

Lo puedes correr,

Directamente,

En CPU,

Que va a funcionar,

Perfectamente,

Y,

Como te da lo mismo,

Que tarde,

10 Segundos,

Que 30,

Vas a obtener,

La información,

Que quieres,

Sin gastarte,

Un duro,

Y sin que tú,

Un duro,

O un euro,

Y sin que esa información,

Salga a internet,

Ni pase por,

Terceros,

Y nada más,

Esto es un poco,

Lo que quería contarte,

En este nuevo episodio,

Espero que te haya gustado,

Y que lo hayas disfrutado,

Tanto como lo he disfrutado,

Yo preparándolo,

Sobre todo,

Después de la adquisición,

De estas dos nuevas herramientas,

JC y Grom,

Si puedes,

Ya sabes,

Una valoración,

En iVoox,

En Apple Podcast,

En Spotify,

En YouTube,

Por supuesto,

Si quieres escribirme,

Atareado.es,

Fantástico,

Porque,

Como bien sabes,

El feedback,

Es el alimento,

Del creador,

De contenido,

O del podcaster,

Según lo escuches,

O lo veas,

Y poco más que decirte,

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 esa red,

Entrando en,

WeTablet Info,

Y de la misma manera,

Si quieres participar,

En el grupo,

De atareado con Linux,

Simplemente tienes que hacer eso,

Buscar atareado con Linux,

Y allí nos vas a encontrar,

Hablando de,

Telegram,

De,

JC,

JQ,

Grom,

Linux,

Inteligencia artificial,

Y cualquier otra cosa,

Que te puedas imaginar,

Y poco más que decirte,

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 JC,

JQ,

Y Grom,

Mejor que mejor,

Un saludo,

Y nos escuchamos,

El próximo lunes,

Hasta luego.

Hasta luego,

Miren,

Hasta luego,

...

Σ,

¡Gracias.

Deja una respuesta