DevOps-bootcamp · Lektion

Redigera YAML-konfigurationsfiler med yq

Läs och ändra Kubernetes- och CI-YAML på plats med yq samtidigt som struktur och kommentarer bevaras.

Lektion 4 av 413 steg

Redigera YAML-konfigurationsfiler med yq är en gratis lektion i DevOps-bootcamp på CoddyKit. Detta är lektion 4 av 4. Du kan läsa vilka 3 lektioner som helst i den här lärvägen kostnadsfritt i sin helhet – därefter låser CoddyKit PRO upp alla lektioner, plus praktisk övning med en inbyggd kodredigerare och en AI-lärare dygnet runt. Den ingår i lärvägen för DevOps-bootcamp, och Era framsteg synkroniseras mellan webben och CoddyKit-appen. Kursen i DevOps-bootcamp innehåller totalt 4 lektioner.

Vad är yq och varför använda det för YAML?

yq är en portabel YAML-processor för kommandoraden, ungefär som jq hanterar JSON. Med det kan ni läsa, filtrera och redigera YAML-filer utan att skriva ett skript i Python eller Ruby.

Det finns två populära verktyg som heter yq:

mikefarah/yq (Go) — underhålls aktivt och stöder YAML, JSON, XML och TOML. Det är den här versionen som används i lektionen.
kislyuk/yq (Python) — en jq-wrapper för YAML; syntaxen skiljer sig åt.

Installera Go-versionen:

brew install yq på macOS
snap install yq på Linux
Eller ladda ned binärfilen: wget https://github.com/mikefarah/yq/releases/latest/download/yq_linux_amd64 -O /usr/local/bin/yq && chmod +x /usr/local/bin/yq

Verifiera installationen: yq --version ska skriva ut v4.x.x. Version 4 använder en annan uttryckssyntax än v3, så versionen är viktig.

# Install yq (Go version) on Linux
wget -q https://github.com/mikefarah/yq/releases/latest/download/yq_linux_amd64 \
  -O /usr/local/bin/yq
chmod +x /usr/local/bin/yq

# Confirm version
yq --version

Läs värden från en Kubernetes Deployment-YAML

Innan ni redigerar något bör ni lära er att läsa YAML-fält. Med en Kubernetes-Deployment kan ni extrahera alla nästlade värden med sökvägar i punktnotation.

Exempelfil: deployment.yaml:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: my-app
  namespace: production
spec:
  replicas: 3
  template:
    spec:
      containers:
        - name: app
          image: my-app:1.0.0

Viktiga läskommandon:

yq '.metadata.name' deployment.yaml — skriver ut my-app
yq '.spec.replicas' deployment.yaml — skriver ut 3
yq '.spec.template.spec.containers[0].image' deployment.yaml — skriver ut my-app:1.0.0

Utdata är vanlig text som standard (utan citattecken). Lägg till flaggan -r eller använd | yq -r om ni behöver råsträngar i skript.

# Create a sample deployment YAML
cat > /tmp/deployment.yaml << 'EOF'
apiVersion: apps/v1
kind: Deployment
metadata:
  name: my-app
  namespace: production
spec:
  replicas: 3
  template:
    spec:
      containers:
        - name: app
          image: my-app:1.0.0
EOF

# Read individual fields
echo "App name:    $(yq '.metadata.name' /tmp/deployment.yaml)"
echo "Replicas:    $(yq '.spec.replicas' /tmp/deployment.yaml)"
echo "Image:       $(yq '.spec.template.spec.containers[0].image' /tmp/deployment.yaml)"

Redigera på plats med flaggan -i

Den viktigaste flaggan för praktisk användning är -i (på plats). Utan den skriver yq ut resultatet till stdout och lämnar filen oförändrad.

Syntax:

Endast läsning (stdout): yq '.spec.replicas' file.yaml
Redigering på plats: yq -i '.spec.replicas = 5' file.yaml

Tilldelningsoperatorn = anger ett värde. Uttrycket är ett fullständigt yq-filter, så ni kan kombinera läsning och skrivning i ett enda steg.

Viktigt: yq -i skriver om hela filen. Kommentarer på samma rad som ett fält bevaras vanligtvis, men fristående kommentarblock kan flyttas. Checka alltid in er YAML i versionshanteringen innan ni kör omfattande redigeringar på plats.

Testa först utan -i och lägg sedan till det när ni är nöjda med resultatet.

# Start with the deployment from the previous scene
echo 'Before:' && yq '.spec.replicas' /tmp/deployment.yaml

# Edit in place: scale to 5 replicas
yq -i '.spec.replicas = 5' /tmp/deployment.yaml

echo 'After:' && yq '.spec.replicas' /tmp/deployment.yaml

Uppdatera containerns image-tagg

En mycket vanlig CI-uppgift är att uppdatera Docker-image-taggen i ett Kubernetes-manifest efter att en ny image har byggts. Med yq blir detta ett enradscommando.

Mönstret är:

Välj containern efter namn med select() för att undvika ett hårdkodat arrayindex.
Använd |= (uppdateringsoperatorn) eller = för att ange det nya värdet.

Med arrayindex (ömtåligt om containerlistan ändras):

yq -i '.spec.template.spec.containers[0].image = "my-app:2.1.0"' deployment.yaml

Med select() (robust):

yq -i '(.spec.template.spec.containers[] | select(.name == "app")).image = "my-app:2.1.0"' deployment.yaml

I en CI-pipeline skulle ni skicka taggen som en shell-variabel:

NEW_TAG="my-app:2.1.0"
CONTAINER_NAME="app"

# Robust update: target by container name, not index
yq -i \
  "(.spec.template.spec.containers[] | select(.name == \"${CONTAINER_NAME}\")).image = \"${NEW_TAG}\"" \
  /tmp/deployment.yaml

# Verify
yq '.spec.template.spec.containers[0].image' /tmp/deployment.yaml

Lägga till och ta bort fält

Förutom att uppdatera befintliga fält kan yq lägga till nya nycklar eller ta bort befintliga.

Lägga till ett fält:

Gör helt enkelt en tilldelning till en sökväg som inte finns: yq -i '.metadata.labels.version = "v2"' file.yaml
Om den överordnade nyckeln (labels) saknas skapar yq den automatiskt.

Ta bort ett fält:

Använd funktionen del(): yq -i 'del(.metadata.annotations)' file.yaml
Ta bort ett arrayelement efter index: yq -i 'del(.spec.template.spec.containers[1])' file.yaml

Lägga till ett element i en array:

yq -i '.spec.template.spec.containers += [{"name": "sidecar", "image": "envoy:latest"}]' file.yaml

# Add a label to the deployment
yq -i '.metadata.labels.version = "v2"' /tmp/deployment.yaml
yq -i '.metadata.labels.managed-by = "ci-pipeline"' /tmp/deployment.yaml

echo '--- Labels after adding ---'
yq '.metadata.labels' /tmp/deployment.yaml

# Delete one label
yq -i 'del(.metadata.labels.managed-by)' /tmp/deployment.yaml

echo '--- Labels after delete ---'
yq '.metadata.labels' /tmp/deployment.yaml

Arbeta med YAML-filer med flera dokument

Kubernetes-manifest innehåller ofta flera resurser i samma fil, separerade med ---. Som standard bearbetar yq alla dokument i en sådan fil.

Viktiga tekniker:

Lista alla dokumenttyper: yq '.[].kind' multi.yaml — observera det inledande .[] för att iterera över dokumenten.
Välj ett specifikt dokument efter typ: yq 'select(.kind == "Service")' multi.yaml
Redigera endast matchande dokument på plats:

yq -i 'select(.kind == "Deployment").spec.replicas = 2' multi.yaml

Dokument som inte matchar predikatet i select() skickas vidare oförändrade, så era Service-, ConfigMap- och andra resurser förblir intakta.

För att dela upp en fil med flera dokument i enskilda filer kan ni loopa över yq-utdata eller använda:

yq -s '.kind' multi.yaml — skriver en fil per dokument, namngiven efter dess .kind-värde.

cat > /tmp/multi.yaml << 'EOF'
apiVersion: apps/v1
kind: Deployment
metadata:
  name: web
spec:
  replicas: 1
---
apiVersion: v1
kind: Service
metadata:
  name: web-svc
spec:
  port: 80
EOF

# Scale ONLY the Deployment, leave Service untouched
yq -i 'select(.kind == "Deployment").spec.replicas = 4' /tmp/multi.yaml

echo '--- Deployment replicas ---'
yq 'select(.kind == "Deployment").spec.replicas' /tmp/multi.yaml

echo '--- Service port (unchanged) ---'
yq 'select(.kind == "Service").spec.port' /tmp/multi.yaml

Patcha en GitHub Actions CI-YAML

CI-konfigurationsfiler (.github/workflows/*.yml, .gitlab-ci.yml) är också YAML. Samma yq-kommandon fungerar, även om sökvägarna kan vara djupt nästlade.

Vanliga CI-patchningsuppgifter:

Lås en runner-version: uppdatera runs-on för alla jobb.
Uppdatera en action-version: hitta steg som använder en viss action och uppdatera dess uses-fält.
Växla en flagga: aktivera eller inaktivera en inställning på workflow-nivå.

Exempel: uppdatera alla steg som använder actions/checkout till v4:

yq -i '(.jobs[].steps[] | select(.uses == "actions/checkout@v3")).uses = "actions/checkout@v4"' .github/workflows/ci.yml

Detta idiom — iterera med [], begränsa med select(), tilldela med = — är grundmönstret för alla strukturerade YAML-redigeringar.

cat > /tmp/ci.yml << 'EOF'
name: CI
on: [push]
jobs:
  build:
    runs-on: ubuntu-22.04
    steps:
      - uses: actions/checkout@v3
      - uses: actions/setup-node@v3
        with:
          node-version: 18
      - run: npm test
  lint:
    runs-on: ubuntu-22.04
    steps:
      - uses: actions/checkout@v3
      - run: npm run lint
EOF

# Bump all checkout steps from v3 → v4
yq -i '(.jobs[].steps[] | select(.uses == "actions/checkout@v3")).uses = "actions/checkout@v4"' \
  /tmp/ci.yml

# Verify both jobs were updated
yq '.jobs[].steps[] | select(.uses | test("checkout")).uses' /tmp/ci.yml

Använda miljövariabler i yq-uttryck

Hårdkodade värden i yq-uttryck gör skript sköra. yq stöder injicering av shell-variabler med funktionen env() eller kortformen strenv().

env(VAR_NAME) — läser miljövariabeln och omvandlar den till lämplig YAML-typ (tal förblir tal, sträng förblir sträng).
strenv(VAR_NAME) — returnerar alltid en sträng, vilket är användbart för image-taggar.

Detta undviker citeringsproblemen med att interpolera variabler i dubbelciterade shell-strängar som innehåller inbäddade YAML-sökvägar.

Mönster:

export IMAGE_TAG="my-app:3.0.0"
yq -i '.spec.template.spec.containers[0].image = strenv(IMAGE_TAG)' deployment.yaml

Använd env() när ni anger numeriska fält som replicas, så att YAML-typen bevaras (heltal, inte en citerad sträng).

export APP_IMAGE="my-app:3.0.0"
export REPLICA_COUNT=6

# Set image using strenv() — result is a YAML string
yq -i '.spec.template.spec.containers[0].image = strenv(APP_IMAGE)' \
  /tmp/deployment.yaml

# Set replicas using env() — result is a YAML integer
yq -i '.spec.replicas = env(REPLICA_COUNT)' \
  /tmp/deployment.yaml

# Confirm types are correct in the output
yq '.spec.replicas, .spec.template.spec.containers[0].image' /tmp/deployment.yaml

Slå samman två YAML-filer

Ibland behöver du tillämpa en patchfil (en liten YAML-fil med åsidosättningar) på en baskonfiguration — till exempel miljöspecifika åsidosättningar i arbetsflöden av Kustomize-typ.

yq kan slå samman två filer med operatorn * för sammanslagning:

yq '. *= load("patch.yaml")' base.yaml — slår samman patchen rekursivt med basen och skriver resultatet till standardutdata.
Lägg till -i för att uppdatera basfilen direkt: yq -i '. *= load("patch.yaml")' base.yaml

Beteende vid sammanslagning:

Skalära värden i patchen skriver över värden i basen.
Mappningar slås samman rekursivt (nycklar som inte finns i patchen bevaras).
Sekvenser (arrayer) ersätts som standard, de läggs inte till i slutet. Använd *+ för att lägga till i stället.

Detta mönster ersätter bräckliga sed-skript som slutar fungera när blanksteg ändras.

cat > /tmp/base.yaml << 'EOF'
app:
  name: my-service
  port: 8080
  debug: false
database:
  host: localhost
  port: 5432
EOF

cat > /tmp/patch.yaml << 'EOF'
app:
  port: 9090
  debug: true
database:
  host: db.production.svc
EOF

# Deep-merge patch into base (stdout preview first)
yq '. *= load("/tmp/patch.yaml")' /tmp/base.yaml

# Apply in place
yq -i '. *= load("/tmp/patch.yaml")' /tmp/base.yaml

Validera YAML och konvertera till JSON

Innan en patchad YAML-fil tillämpas på ett kluster är det god praxis att validera den och vid behov konvertera den till JSON för andra verktyg.

Validera syntax:

yq '.' file.yaml && echo "Valid" — yq avslutas med kod 1 vid tolkningsfel, så detta fungerar i CI-kontroller.

Konvertera YAML till JSON:

yq -o=json '.' file.yaml — skriver ut formaterad JSON.
Skicka vidare till jq för ytterligare JSON-bearbetning: yq -o=json '.' file.yaml | jq '.metadata.name'

Konvertera JSON till YAML:

yq -P '.' file.json — flaggan -P tvingar fram YAML-utdata (prettyprint) när indata är JSON.

Dessa konverteringar gör yq till en brygga mellan YAML-baserade verktyg (Helm, kubectl) och JSON-baserade verktyg (Terraform, AWS CLI, jq).

# Validate YAML (exits 0 on success, 1 on parse error)
if yq '.' /tmp/deployment.yaml > /dev/null 2>&1; then
  echo "YAML is valid"
else
  echo "YAML parse error!" >&2
  exit 1
fi

# Convert to JSON and query with jq
yq -o=json '.' /tmp/deployment.yaml \
  | jq '{name: .metadata.name, image: .spec.template.spec.containers[0].image}'

# Round-trip: JSON snippet back to YAML
echo '{"replicas": 7, "strategy": "RollingUpdate"}' \
  | yq -P '.'

Ett komplett CI-skript för att patcha en Deployment

Här kombineras alla tekniker i ett verkligt CI-skript som patchar ett Kubernetes-Deployment-manifest som en del av en GitOps-pipeline.

Skriptet:

Validerar indata-YAML innan den ändras.
Använder env() / strenv() för alla variabelsubstitutioner.
Uppdaterar containerns image-tagg med en namn-baserad select().
Ökar antalet repliker.
Stämplar en deploy-time-annotering med den aktuella tidsstämpeln.
Validerar utdata igen innan ändringarna checkas in.

Detta mönster säkerställer att varje steg är atomiskt och granskningsbart, även om pipelinen körs samtidigt på flera håll.

#!/usr/bin/env bash
set -euo pipefail

MANIFEST="/tmp/deployment.yaml"
export NEW_IMAGE="my-app:$(date +%Y%m%d)-abc1234"
export NEW_REPLICAS=3
export DEPLOY_TIME="$(date -u +%Y-%m-%dT%H:%M:%SZ)"
export CONTAINER="app"

# 1. Validate before patching
yq '.' "$MANIFEST" > /dev/null

# 2. Update image (by container name)
yq -i \
  '(.spec.template.spec.containers[] | select(.name == strenv(CONTAINER))).image = strenv(NEW_IMAGE)' \
  "$MANIFEST"

# 3. Set replicas
yq -i '.spec.replicas = env(NEW_REPLICAS)' "$MANIFEST"

# 4. Stamp annotation
yq -i '.metadata.annotations."deploy-time" = strenv(DEPLOY_TIME)' "$MANIFEST"

# 5. Validate result
yq '.' "$MANIFEST" > /dev/null && echo "Patch applied successfully"

# 6. Show diff summary
yq '{image: .spec.template.spec.containers[0].image, replicas: .spec.replicas}' "$MANIFEST"

Kunskapskontroll: säker redigering av flera dokument

Testa dina kunskaper om redigering av Kubernetes YAML-filer med flera dokument med yq.

Besvara frågan i den interaktiva lektionen

Sammanfattning av lektionen: redigera YAML med yq

Du har slutfört lektionen om redigering av YAML-konfigurationsfiler med yq. Här är en kort sammanfattning av allt som behandlats:

Installation: Använd mikefarah/yq:s Go-binär (v4). Verifiera med yq --version.
Läsning: Sökvägar med punktnotation, till exempel .spec.replicas; åtkomst till arrayer med [0] eller iteration med [].
Redigering på plats: Flaggan -i skriver om filen. Förhandsgranska alltid utan -i först.
Robust målsökning: Föredra select(.name == "app") framför hårdkodade arrayindex.
Lägga till / ta bort: Tilldela ett nytt fält för att skapa det; använd del() för att ta bort fält.
Filer med flera dokument: Använd select(.kind == "...") för att välja en resurs och lämna övriga orörda.
CI-variabler: Använd strenv(VAR) för strängar och env(VAR) för typade värden — det undviker problem med citattecken i skalet.
Sammanslagning: . *= load("patch.yaml") slår samman en åsidosättningsfil rekursivt utan att förlora nycklar som inte patchas.
Validering och konvertering: Använd yq '.' som lint-kontroll och -o=json samt -P för formatkonvertering.

Kärnmönstret för alla YAML-patchar i CI är: validera → välj → tilldela → validera. Kombinera detta med strenv() och select(), så behöver du aldrig mer ta till bräckliga sed-one-liners.

Gratis att börja

Lär dig DevOps-bootcamp med en AI-lärare – gratis

Skriv och kör riktig kod i webbläsaren, få omedelbar hjälp av en AI-lärare dygnet runt och fortsätt där du slutade – på webben eller i appen.

Kurser: 142
Lektioner: 568

Börja lära dig gratis Visa hela kursen

Vanliga frågor

Är lektionen ”Redigera YAML-konfigurationsfiler med yq” gratis?

Ja – du kan läsa vilka 3 lektioner som helst i lärvägen DevOps-bootcamp, inklusive ”Redigera YAML-konfigurationsfiler med yq”, kostnadsfritt i sin helhet här på webben. Därefter låser CoddyKit PRO upp alla lektioner, plus interaktiv övning med en inbyggd kodredigerare och en AI-lärare dygnet runt. Kursen i DevOps-bootcamp innehåller totalt 4 lektioner.

Vad lär jag mig i ”Redigera YAML-konfigurationsfiler med yq”?

Läs och ändra Kubernetes- och CI-YAML på plats med yq samtidigt som struktur och kommentarer bevaras. Ni övar på DevOps-bootcamp med praktisk kod som körs direkt i webbläsaren, medan en AI-handledare som är tillgänglig dygnet runt svarar på Era frågor under lektionen.

Behöver jag någon erfarenhet för att börja lära mig DevOps-bootcamp?

Du behöver inga förkunskaper. Utbildningen i DevOps-bootcamp på CoddyKit är upplagd för allt från nybörjare till avancerade elever, så att du kan börja här eller från början och gå fram i din egen takt. Detta är lektion 4 av 4.

Hur lång tid tar lektionen ”Redigera YAML-konfigurationsfiler med yq”?

De flesta CoddyKit-lektioner tar cirka 5–10 minuter. Varje lektion är kort och interaktiv, så att du gör stadiga framsteg och kan fortsätta precis där du slutade – på webben eller i appen.

Kan jag skriva och köra kod i den här DevOps-bootcamp-lektionen?

Ja. Varje DevOps-bootcamp-lektion innehåller en inbyggd kodredigerare, så att du kan skriva och köra riktig kod direkt i webbläsaren och få omedelbar AI-feedback – utan lokal installation.

Alla lektioner i den här kursen

Filtrera och välja JSON med jq-pipelines
Omforma och skapa JSON-objekt med jq
Anropa REST-API:er med curl och jq tillsammans
Redigera YAML-konfigurationsfiler med yq

← Tillbaka till DevOps-bootcamp