Arbeiten mit strukturierten Datenformaten auf der Shell kann anstrengend sein – wenn man noch nicht die richtigen Tools dafür hat. Ob JSON aus einer API, YAML aus Kubernetes-Manifests oder riesige Logfiles – ohne passende Helferlein endet man schnell bei unübersichtlichem grep, less und Copy&Paste.

Zum Glück gibt es eine Reihe von Werkzeugen, die genau dafür gemacht sind:

• jq – JSON lesen, filtern und transformieren – https://jqlang.org
• jo – JSON in der Shell erzeugen – https://github.com/jpmens/jo
• yq – YAML lesen, bearbeiten und konvertieren – https://mikefarah.gitbook.io/yq/
• jless / yless – interaktiv in JSON/YAML navigieren – https://jless.io

In diesem Beitrag stelle ich euch diese Tools vor – mit Beispielen, die ihr direkt in eurer eigenen Shell ausprobieren könnt.

jq – der Klassiker für JSON

Das vermutlich bekannteste und am weitesten verbreitete Tool für JSON ist jq. Es ist so etwas wie der Schweizer Taschenmesser für JSON:

• formatiert unlesbare Minified-JSON-Dateien,
• extrahiert gezielt Werte,
• filtert und transformiert Daten,
• eignet sich für einmalige Ad-hoc-Analysen genauso wie für Skripte.

Ein einfaches Beispiel: JSON schön formatieren:

$ cat data.json
{"user":{"id":42,"name":"Alice"},"active":true}
$ cat data.json | jq # oder `jq < data.json`

{
  "user": {
    "id": 42,
    "name": "Alice"
  },
  "active": true
}

So schnell wird aus einem unübersichtlichen Einzeiler eine lesbare Struktur.

Mann kann es aber auch super in scripten verwenden um Daten aus json zu extrahieren:

get_current_gitlab_token() {
    kubectl get secret $SECRETNAME -n $INITIALNAMESPACE -o json |
        jq -r '.data[".dockerconfigjson"]' 2>/dev/null |
        base64 --decode |
        jq -r '.auths["registry.gitlab.com"].password' 2>/dev/null
}

Oder um in einem JSON-File Daten einzutragen:

kubectl get secrets shipa-certificates -o json \
        | jq ".data[\"ca.pem\"] |= \"$CA_CERT\"" \
        | kubectl apply -f -

jq kann noch viel mehr. Wer das Werkzeug noch nicht kennt sollte unbedingt ein paar Minuten investieren um das Tutorial querzulesen, und dann bei der nächsten Einsatzmöglichkeit gezielt nach der Syntax schauen. Pro tip: KI's können diese Syntax prima, und jless (kommt gleich) kann diese auch generieren.

jo – JSON in der Shell erzeugen

Während jq ideal zum Lesen und Transformieren ist, eignet sich jo perfekt, um JSON direkt in der Shell zu erstellen. Damit lassen sich Testdaten oder API-Payloads schnell zusammenbauen.

Ein einfaches Beispiel:

jo name=Alice age=30 active=true

Ausgabe:

{"name":"Alice","age":30,"active":true}

Auch Arrays sind möglich:

jo -a red green blue

➜ ["red","green","blue"]

Verschachtelte Objekte:

jo user=$(jo name=Alice id=42) project=Demo

➜ {"user":{"name":"Alice","id":42},"project":"Demo"}

Das eignet sich sehr gut für schnelle curl-Requests, aber insbesondere auch für shell scripte in denen inline json sonst sehr schnell sehr unübersichtlich wird:

curl -X POST -H "Content-Type: application/json" \
     -d "$(jo username=dev password=secret)" \
     https://example.com/api/login

yq – YAML lesen und bearbeiten

YAML verwenden wir überall, am meisten habe ich in Kubernetes damit zu tun. yq ist das Werkzeug der Wahl, um YAML-Dateien zu lesen, zu durchsuchen und zu editieren. Die Syntax ist sehr nahe an jq, das Werkzeug kann neben YAML aber auch JSON, TOML und XML verarbeiten, und zwischen diesesn Konvertieren. Im wesentlichen kann es das gleiche wie jq, eben auch für YAML.

jless & yless – interaktiv stöbern

Wenn Dateien zu groß oder zu komplex werden, helfen jless und yless (ein alias yless=jless --yaml. Sie bieten eine interaktive Ansicht für JSON und YAML – mit:

• Syntax-Highlighting,
• Falten und Aufklappen von Strukturen,
• komfortabler Navigation und Suche.

Beispiel:

kubectl get pods -oyaml | yless

Das schöne: Man kann hier auf der Shell wunderbar uninteressante textblöcke einklappen um schnell die wichtigen Informationen zu fokussieren, und dann über Tastaturkommandos werte, oder jq/yq filter auf das aktuell ausgewählte Element kopieren, um das z.B. dann auf alle Pods in einem Namespace anzuwenden.

Fazit

Mit diesen Tools – jq, jo, yq, jless und yless – wird das Arbeiten mit JSON und YAML auf der Shell deutlich angenehmer. Sehr gut investierte Zeit diese Werkzeuge (eines nach dem Anderen) zu lernen.