DevOps बूटकैंप · पाठ

yq से YAML कॉन्फ़िगरेशन फ़ाइलों का संपादन

संरचना और टिप्पणियाँ सुरक्षित रखते हुए yq से Kubernetes और CI YAML को उसी स्थान पर पढ़ें और संशोधित करें।

पाठ 4, कुल 4 में से13 चरण

yq से YAML कॉन्फ़िगरेशन फ़ाइलों का संपादन, CoddyKit पर DevOps बूटकैंप का एक निःशुल्क पाठ है। यह 4 में से 4वाँ पाठ है। इस अध्ययन पथ के 3 तक कोई भी पाठ पूरा पढ़ना निःशुल्क है — इसके बाद CoddyKit PRO हर पाठ अनलॉक करता है, साथ ही अंतर्निर्मित कोड संपादक और चौबीसों घंटे एआई शिक्षक के साथ व्यावहारिक अभ्यास भी उपलब्ध कराता है। यह DevOps बूटकैंप सीखने के मार्ग का हिस्सा है और आपकी प्रगति वेब तथा CoddyKit ऐप पर सिंक होती रहती है। DevOps बूटकैंप पाठ्यक्रम में कुल 4 पाठ शामिल हैं।

yq क्या है और YAML के लिए इसका उपयोग क्यों करें

yq एक पोर्टेबल कमांड-लाइन YAML प्रोसेसर है, ठीक उसी तरह जैसे jq JSON को संभालता है। इसकी सहायता से आप Python या Ruby में स्क्रिप्ट लिखे बिना YAML फ़ाइलें पढ़, फ़िल्टर और संपादित कर सकते हैं।

yq नाम वाले दो लोकप्रिय टूल हैं:

mikefarah/yq (Go) — सक्रिय रूप से अनुरक्षित, YAML, JSON, XML और TOML का समर्थन करता है। इस पाठ में इसी संस्करण का उपयोग किया गया है।
kislyuk/yq (Python) — YAML के लिए jq रैपर; इसका सिंटैक्स अलग है।

Go संस्करण इंस्टॉल करें:

macOS पर brew install yq
Linux पर snap install yq
या बाइनरी डाउनलोड करें: wget https://github.com/mikefarah/yq/releases/latest/download/yq_linux_amd64 -O /usr/local/bin/yq && chmod +x /usr/local/bin/yq

सत्यापित करें: yq --version को v4.x.x प्रिंट करना चाहिए। संस्करण 4 में v3 से अलग अभिव्यक्ति सिंटैक्स है, इसलिए संस्करण महत्वपूर्ण है।

# 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

Kubernetes Deployment YAML से मान पढ़ना

कुछ भी संपादित करने से पहले YAML फ़ील्ड को पढ़ना सीखें। Kubernetes Deployment में डॉट-नोटेशन पथों की सहायता से आप कोई भी नेस्टेड मान निकाल सकते हैं।

उदाहरण 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

मुख्य रीड कमांड:

yq '.metadata.name' deployment.yaml — my-app प्रिंट करता है
yq '.spec.replicas' deployment.yaml — 3 प्रिंट करता है
yq '.spec.template.spec.containers[0].image' deployment.yaml — my-app:1.0.0 प्रिंट करता है

डिफ़ॉल्ट रूप से आउटपुट सादा टेक्स्ट होता है (उद्धरण के बिना)। यदि आपको स्क्रिप्ट में कच्चे स्ट्रिंग मान चाहिए, तो -r फ़्लैग जोड़ें या | yq -r का उपयोग करें।

# 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)"

-i फ़्लैग से फ़ाइल को उसी स्थान पर संपादित करना

वास्तविक उपयोग के लिए सबसे महत्वपूर्ण फ़्लैग -i (उसी स्थान पर संपादन) है। इसके बिना yq परिणामों को stdout में प्रिंट करता है और फ़ाइल को अपरिवर्तित छोड़ देता है।

सिंटैक्स:

केवल पढ़ना (stdout): yq '.spec.replicas' file.yaml
उसी स्थान पर संपादन: yq -i '.spec.replicas = 5' file.yaml

असाइनमेंट ऑपरेटर = किसी मान को सेट करता है। अभिव्यक्ति एक पूर्ण yq फ़िल्टर है, इसलिए आप एक ही पास में पढ़ने और लिखने को मिला सकते हैं।

महत्वपूर्ण: yq -i फ़ाइल को पूरी तरह से दोबारा लिखता है। किसी फ़ील्ड वाली पंक्ति के अंत में लिखी टिप्पणियाँ सामान्यतः सुरक्षित रहती हैं, लेकिन अलग टिप्पणी ब्लॉक स्थान बदल सकते हैं। बड़े पैमाने पर उसी स्थान पर संपादन करने से पहले हमेशा अपने YAML को संस्करण नियंत्रण में कमिट करें।

पहले -i के बिना परीक्षण करें, फिर आउटपुट से संतुष्ट होने पर इसे जोड़ें।

# 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

कंटेनर इमेज टैग अपडेट करना

एक बहुत सामान्य CI कार्य है नई इमेज बनने के बाद Kubernetes मैनिफ़ेस्ट में Docker इमेज टैग बढ़ाना। yq की सहायता से यह एक ही कमांड में किया जा सकता है।

पैटर्न यह है:

select() की सहायता से कंटेनर को नाम के आधार पर चुनें, ताकि ऐरे इंडेक्स 0 को सीधे लिखने से बचा जा सके।
नया मान सेट करने के लिए |= (अपडेट ऑपरेटर) या = का उपयोग करें।

ऐरे इंडेक्स का उपयोग (कंटेनर सूची बदलने पर अस्थिर):

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

select() का उपयोग (विश्वसनीय):

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

CI pipeline में आप टैग को शेल वेरिएबल के रूप में भेजेंगे:

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

फ़ील्ड जोड़ना और हटाना

मौजूदा फ़ील्ड अपडेट करने के अलावा, yq नई कुंजियाँ जोड़ या मौजूदा कुंजियाँ हटा सकता है।

फ़ील्ड जोड़ना:

ऐसे पथ को असाइन करें जो मौजूद नहीं है: yq -i '.metadata.labels.version = "v2"' file.yaml
यदि पैरेंट कुंजी (labels) मौजूद नहीं है, तो yq उसे अपने आप बना देता है।

फ़ील्ड हटाना:

del() फ़ंक्शन का उपयोग करें: yq -i 'del(.metadata.annotations)' file.yaml
ऐरे एलिमेंट को इंडेक्स से हटाएँ: yq -i 'del(.spec.template.spec.containers[1])' file.yaml

ऐरे में एलिमेंट जोड़ना:

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

बहु-दस्तावेज़ YAML फ़ाइलों के साथ काम करना

Kubernetes मैनिफ़ेस्ट अक्सर एक ही फ़ाइल में कई संसाधनों को --- से अलग करके रखते हैं। डिफ़ॉल्ट रूप से yq ऐसी फ़ाइल के सभी दस्तावेज़ों को प्रोसेस करता है।

मुख्य तकनीकें:

सभी दस्तावेज़ प्रकार सूचीबद्ध करें: yq '.[].kind' multi.yaml — दस्तावेज़ों पर इटरेट करने के लिए शुरुआत में .[] पर ध्यान दें।
प्रकार के आधार पर किसी विशिष्ट दस्तावेज़ को चुनें: yq 'select(.kind == "Service")' multi.yaml
केवल मेल खाने वाले दस्तावेज़ों को उसी स्थान पर संपादित करें:

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

जो दस्तावेज़ select() प्रेडिकेट से मेल नहीं खाते, वे बिना बदलाव के आगे भेज दिए जाते हैं, इसलिए आपके Service, ConfigMap और अन्य संसाधन सुरक्षित रहते हैं।

बहु-दस्तावेज़ फ़ाइल को अलग-अलग फ़ाइलों में बाँटने के लिए आप yq के आउटपुट पर लूप चला सकते हैं या इसका उपयोग कर सकते हैं:

yq -s '.kind' multi.yaml — हर दस्तावेज़ के लिए उसके .kind मान के नाम वाली एक फ़ाइल लिखता है।

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

GitHub Actions CI YAML में पैच लगाना

CI कॉन्फ़िगरेशन फ़ाइलें (.github/workflows/*.yml, .gitlab-ci.yml) भी YAML होती हैं। वही yq कमांड काम करते हैं, हालांकि पथ बहुत गहराई तक नेस्टेड हो सकते हैं।

CI पैच लगाने के सामान्य कार्य:

रनर संस्करण को स्थिर करना: सभी जॉब में runs-on अपडेट करें।
एक्शन संस्करण अपडेट करना: किसी विशेष एक्शन का उपयोग करने वाले चरण खोजें और उसका uses फ़ील्ड बढ़ाएँ।
फ़्लैग बदलना: कार्यप्रवाह-स्तरीय सेटिंग को सक्षम या अक्षम करें।

उदाहरण: actions/checkout का उपयोग करने वाले सभी चरणों को v4 में अपडेट करें:

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

यह तरीका — [] से इटरेट करना, select() से दायरा सीमित करना और = से असाइन करना — किसी भी संरचित YAML संपादन का मुख्य पैटर्न है।

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

yq अभिव्यक्तियों में पर्यावरणीय वेरिएबल का उपयोग करना

yq अभिव्यक्तियों में मानों को सीधे लिखने से स्क्रिप्ट अस्थिर हो जाती हैं। yq env() फ़ंक्शन या strenv() संक्षिप्त रूप की सहायता से शेल वेरिएबल डालने का समर्थन करता है।

env(VAR_NAME) — पर्यावरणीय वेरिएबल पढ़ता है और उसे उपयुक्त YAML प्रकार में बदलता है (संख्या संख्या ही रहती है और स्ट्रिंग स्ट्रिंग ही रहती है)।
strenv(VAR_NAME) — हमेशा स्ट्रिंग लौटाता है, इसलिए इमेज टैग के लिए उपयोगी है।

इससे YAML पथों को शामिल करने वाली दोहरे-उद्धरण वाली शेल स्ट्रिंग में वेरिएबल डालने की जटिल उद्धरण समस्या से बचा जा सकता है।

पैटर्न:

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

replicas जैसे संख्यात्मक फ़ील्ड सेट करते समय env() का उपयोग करें, ताकि YAML प्रकार सुरक्षित रहे (उद्धरण वाली स्ट्रिंग के बजाय पूर्णांक)।

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

दो YAML फ़ाइलों को मिलाना

कभी-कभी आपको किसी आधार कॉन्फ़िगरेशन पर एक पैच फ़ाइल (छोटा ओवरराइड YAML) लागू करना पड़ता है — उदाहरण के लिए, Kustomize-शैली के कार्यप्रवाहों में पर्यावरण-विशिष्ट ओवरराइड के लिए।

yq, * मर्ज ऑपरेटर का उपयोग करके दो फ़ाइलों को मिला सकता है:

yq '. *= load("patch.yaml")' base.yaml — पैच को आधार में गहराई से मर्ज करता है और परिणाम को मानक आउटपुट में लिखता है।
आधार फ़ाइल को उसी स्थान पर अपडेट करने के लिए -i जोड़ें: yq -i '. *= load("patch.yaml")' base.yaml

मर्ज का व्यवहार:

पैच में मौजूद स्केलर मान आधार के मानों को अधिलेखित कर देते हैं।
मैपिंग को गहराई से मर्ज किया जाता है (पैच में मौजूद न होने वाली कुंजियाँ सुरक्षित रहती हैं)।
अनुक्रम (ऐरे) डिफ़ॉल्ट रूप से बदल दिए जाते हैं, उनमें नए मान जोड़े नहीं जाते। इसके बजाय जोड़ने के लिए *+ का उपयोग करें।

यह तरीका ऐसे नाज़ुक sed स्क्रिप्ट की जगह लेता है जो रिक्त स्थान में बदलाव होने पर काम करना बंद कर देती हैं।

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

YAML का सत्यापन और JSON में रूपांतरण

क्लस्टर पर पैच किया हुआ YAML लागू करने से पहले उसका सत्यापन करना और आवश्यकता होने पर उसे अन्य टूल के लिए JSON में बदलना अच्छी प्रक्रिया है।

वाक्यविन्यास का सत्यापन:

yq '.' file.yaml && echo "Valid" — पार्सिंग त्रुटि होने पर yq कोड 1 के साथ बाहर निकलता है, इसलिए यह CI जाँच-द्वारों में काम करता है।

YAML को JSON में बदलना:

yq -o=json '.' file.yaml — सुंदर रूप में JSON आउटपुट देता है।
आगे JSON संसाधित करने के लिए इसे jq में पाइप करें: yq -o=json '.' file.yaml | jq '.metadata.name'

JSON को YAML में बदलना:

yq -P '.' file.json — इनपुट JSON होने पर -P फ़्लैग YAML (सुंदर रूप में) आउटपुट के लिए बाध्य करता है।

ये रूपांतरण yq को YAML-आधारित टूल (Helm, kubectl) और JSON-आधारित टूल (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 '.'

CI परिनियोजन पैच स्क्रिप्ट का संपूर्ण उदाहरण

सभी तकनीकों को एक साथ मिलाकर: GitOps पाइपलाइन के हिस्से के रूप में Kubernetes Deployment मैनिफ़ेस्ट में पैच लगाने वाली एक वास्तविक CI स्क्रिप्ट।

स्क्रिप्ट:

इनपुट YAML को छूने से पहले उसका सत्यापन करती है।
सभी चर प्रतिस्थापनों के लिए env() / strenv() का उपयोग करती है।
नाम-आधारित select() का उपयोग करके कंटेनर इमेज टैग अपडेट करती है।
प्रतिकृतियों की संख्या बढ़ाती है।
वर्तमान टाइमस्टैम्प के साथ deploy-time एनोटेशन जोड़ती है।
कमिट करने से पहले आउटपुट का फिर से सत्यापन करती है।

यह तरीका सुनिश्चित करता है कि पाइपलाइन एक साथ चलने पर भी प्रत्येक चरण परमाणु और ऑडिट योग्य रहे।

#!/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"

ज्ञान-जाँच: अनेक दस्तावेज़ों का सुरक्षित संपादन

yq के साथ अनेक-दस्तावेज़ Kubernetes YAML फ़ाइलों को संपादित करने की अपनी समझ जाँचें।

इंटरैक्टिव पाठ में इसका उत्तर दें

पाठ का पुनरावलोकन: yq से YAML का संपादन

आपने yq से YAML कॉन्फ़िगरेशन फ़ाइलों का संपादन वाला पाठ पूरा कर लिया है। इसमें सिखाई गई सभी बातों का संक्षिप्त सारांश यहाँ दिया गया है:

इंस्टॉलेशन: mikefarah/yq Go बाइनरी (v4) का उपयोग करें। yq --version से जाँच करें।
पढ़ना: .spec.replicas जैसे डॉट-नोटेशन पथ; [0] या [] पुनरावृत्ति से ऐरे तक पहुँचना।
उसी स्थान पर संपादन: -i फ़्लैग फ़ाइल को फिर से लिखता है। पहले हमेशा -i के बिना पूर्वावलोकन करें।
विश्वसनीय लक्ष्य-निर्धारण: हार्ड-कोड किए गए ऐरे इंडेक्स की जगह select(.name == "app") को प्राथमिकता दें।
जोड़ना / हटाना: नया पथ बनाने के लिए उसमें मान असाइन करें; फ़ील्ड हटाने के लिए del() का उपयोग करें।
अनेक-दस्तावेज़ वाली फ़ाइलें: किसी एक संसाधन को लक्ष्य बनाने और अन्य को बिना बदले छोड़ने के लिए select(.kind == "...") का उपयोग करें।
CI चर: स्ट्रिंग के लिए strenv(VAR) और प्रकारयुक्त मानों के लिए env(VAR) का उपयोग करें — इससे शेल कोटिंग की त्रुटियों से बचा जा सकता है।
मर्ज करना: . *= load("patch.yaml") ओवरराइड फ़ाइल को गहराई से मर्ज करता है और बिना पैच की गई कुंजियों को सुरक्षित रखता है।
सत्यापन और रूपांतरण: लिंट जाँच-द्वार के रूप में yq '.'; प्रारूप रूपांतरण के लिए -o=json और -P।

CI में किसी भी YAML पैच के लिए मूल पैटर्न है: सत्यापित करें → चुनें → असाइन करें → सत्यापित करें। इसे strenv() और select() के साथ मिलाने पर आपको फिर कभी नाज़ुक sed वन-लाइनर की आवश्यकता नहीं पड़ेगी।

शुरुआत निःशुल्क

एआई शिक्षक के साथ DevOps बूटकैंप सीखें — निःशुल्क

अपने ब्राउज़र में वास्तविक कोड लिखें और चलाएँ, चौबीसों घंटे एआई शिक्षक से तुरंत सहायता पाएँ, और वेब या ऐप पर वहीं से शुरू करें जहाँ आपने छोड़ा था।

पाठ्यक्रम: 142
पाठ: 568

निःशुल्क सीखना शुरू करें पूरा पाठ्यक्रम देखें

अक्सर पूछे जाने वाले प्रश्न

क्या “yq से YAML कॉन्फ़िगरेशन फ़ाइलों का संपादन” पाठ निःशुल्क है?

हाँ — DevOps बूटकैंप अध्ययन पथ के 3 तक कोई भी पाठ, जिसमें “yq से YAML कॉन्फ़िगरेशन फ़ाइलों का संपादन” भी शामिल है, यहाँ वेब पर पूरा पढ़ना निःशुल्क है। इसके बाद CoddyKit PRO हर पाठ अनलॉक करता है, साथ ही अंतर्निर्मित कोड संपादक और चौबीसों घंटे एआई शिक्षक के साथ इंटरैक्टिव अभ्यास भी उपलब्ध कराता है। DevOps बूटकैंप पाठ्यक्रम में कुल 4 पाठ शामिल हैं।

“yq से YAML कॉन्फ़िगरेशन फ़ाइलों का संपादन” में मैं क्या सीखूँगा?

संरचना और टिप्पणियाँ सुरक्षित रखते हुए yq से Kubernetes और CI YAML को उसी स्थान पर पढ़ें और संशोधित करें। आप ब्राउज़र में सीधे चलाए जाने वाले व्यावहारिक कोड के साथ DevOps बूटकैंप का अभ्यास करते हैं, और पाठ पूरा करते समय 24/7 एआई ट्यूटर आपके प्रश्नों के उत्तर देता है।

क्या DevOps बूटकैंप शुरू करने के लिए मुझे किसी अनुभव की आवश्यकता है?

पहले के अनुभव की आवश्यकता नहीं है। CoddyKit पर DevOps बूटकैंप शुरुआती से लेकर उन्नत शिक्षार्थियों तक सभी के लिए व्यवस्थित किया गया है, इसलिए आप यहीं से या शुरुआत से सीखना शुरू कर सकते हैं और अपनी गति से आगे बढ़ सकते हैं। यह 4 में से 4वाँ पाठ है।

“yq से YAML कॉन्फ़िगरेशन फ़ाइलों का संपादन” पाठ पूरा करने में कितना समय लगता है?

CoddyKit का अधिकांश पाठ लगभग 5–10 मिनट में पूरा हो जाता है। हर पाठ छोटा और संवादात्मक है, इसलिए आप लगातार प्रगति करते हैं और वेब या ऐप पर वहीं से सीखना जारी रख सकते हैं जहाँ आपने छोड़ा था।

क्या मैं इस DevOps बूटकैंप पाठ में कोड लिख और चला सकता हूँ?

हाँ। हर DevOps बूटकैंप पाठ में एक अंतर्निर्मित कोड संपादक शामिल है, जिससे आप सीधे अपने ब्राउज़र में वास्तविक कोड लिख और चला सकते हैं और तुरंत एआई प्रतिक्रिया पा सकते हैं—स्थानीय सेटअप की आवश्यकता नहीं है।

इस पाठ्यक्रम के सभी पाठ

jq पाइपलाइनों से JSON फ़िल्टर और चयन
jq से JSON ऑब्जेक्ट बदलना और बनाना
curl और jq से REST API का उपयोग
yq से YAML कॉन्फ़िगरेशन फ़ाइलों का संपादन

← DevOps बूटकैंप पर वापस जाएँ