YAML Validator: Check & Fix YAML Syntax Online

# VALID: env is a child of container
spec:
  containers:
    - name: app
      image: myapp:latest
      env:
        - name: PORT
          value: "8080"

# BROKEN: off-by-one-space — env is now a sibling of containers, not a child
spec:
  containers:
    - name: app
      image: myapp:latest
     env:           # ← 5 spaces instead of 6
       - name: PORT
         value: "8080"
# Error: yaml: line 8: mapping values are not allowed in this context

# .editorconfig — prevents tabs in YAML files
[*.{yaml,yml}]
indent_style = space
indent_size = 2
trim_trailing_whitespace = true
insert_final_newline = true

# VS Code settings.json
{
  "[yaml]": {
    "editor.insertSpaces": true,
    "editor.tabSize": 2,
    "editor.detectIndentation": false
  }
}

# YAML 1.1 type coercions that bite developers

# Version strings → floats (the most common config bug)
version: 1.10       # → float 1.1 (not "1.10"!) — this is a major version, broken
version: "1.10"     # → string "1.10" (safe)

# Country codes / environment names → booleans (Norway Problem)
country: NO         # → false  (YAML 1.1)
country: "NO"       # → "NO"   (safe)
env: ON             # → true   (YAML 1.1)
env: "ON"           # → "ON"   (safe)

# Octal numbers (YAML 1.1 only)
mode: 0755          # → integer 493 (octal interpretation)
mode: "0755"        # → string "0755" (safe)

# Null coercion
key: ~              # → null
key: null           # → null (both YAML 1.1 and 1.2)
key: Null           # → null (YAML 1.1 only; string in YAML 1.2)

# Infinity and NaN
value: .inf         # → +Infinity (float)
value: .nan         # → NaN (float) — breaks JSON serialization

# Literal block (|) — preserves all newlines
sql_query: |
  SELECT id, name
  FROM users
  WHERE active = true
# Value: "SELECT id, name
FROM users
WHERE active = true
" (trailing newline included)

# Folded block (>) — newlines become spaces (except blank lines)
description: >
  This is a long
  description that wraps
  across multiple lines.
# Value: "This is a long description that wraps across multiple lines.
"

# Chomping modifiers (often forgotten):
key: |    # default: keep one trailing newline
key: |-   # strip all trailing newlines
key: |+   # keep all trailing newlines

# Flow scalars: be careful with special characters
command: kubectl apply -f config.yaml  # fine
command: kubectl apply -f "file:name"  # YAML parses the colon as a key!
command: "kubectl apply -f "file:name""  # must escape inner quotes

# Python — basic syntax check
python3 -c "
import yaml, sys
try:
    yaml.safe_load(open(sys.argv[1]).read())
    print('Valid YAML')
except yaml.YAMLError as e:
    print(f'Error: {e}')
    sys.exit(1)
" config.yaml

# Node.js — with js-yaml
node -e "
const yaml = require('js-yaml');
const fs = require('fs');
try {
  yaml.load(fs.readFileSync(process.argv[2], 'utf8'));
  console.log('Valid YAML');
} catch(e) {
  console.error('Error at line', e.mark?.line + 1 + ':', e.reason);
  process.exit(1);
}
" config.yaml

# yq — simplest one-liner
yq eval config.yaml > /dev/null && echo "Valid" || echo "Invalid"

# Python: YAML + JSON Schema validation with jsonschema
import yaml
import jsonschema
import json

# JSON Schema defining the expected structure
schema = {
    "type": "object",
    "required": ["version", "services"],
    "properties": {
        "version": {"type": "string", "pattern": "^[0-9]+\.[0-9]+$"},
        "services": {
            "type": "object",
            "additionalProperties": {
                "type": "object",
                "required": ["image"],
                "properties": {
                    "image": {"type": "string"},
                    "ports": {"type": "array", "items": {"type": "string"}},
                    "environment": {"type": "object"}
                }
            }
        }
    }
}

with open("docker-compose.yaml") as f:
    data = yaml.safe_load(f)

try:
    jsonschema.validate(data, schema)
    print("Valid!")
except jsonschema.ValidationError as e:
    print(f"Schema error at {' -> '.join(str(p) for p in e.absolute_path)}:")
    print(f"  {e.message}")

// TypeScript: YAML + Zod schema validation
import yaml from 'js-yaml'
import { z } from 'zod'
import fs from 'fs'

const ServiceSchema = z.object({
  image: z.string(),
  ports: z.array(z.string()).optional(),
  environment: z.record(z.string()).optional(),
  restart: z.enum(['no', 'always', 'on-failure', 'unless-stopped']).optional(),
})

const ComposeSchema = z.object({
  version: z.string().regex(/^d+.d+$/),
  services: z.record(ServiceSchema),
  networks: z.record(z.object({ driver: z.string() })).optional(),
})

const raw = yaml.load(fs.readFileSync('docker-compose.yaml', 'utf-8'))
const result = ComposeSchema.safeParse(raw)

if (!result.success) {
  console.error('Validation errors:')
  result.error.issues.forEach(issue => {
    console.error(`  ${issue.path.join('.')}: ${issue.message}`)
  })
  process.exit(1)
}

console.log('Config valid:', result.data)

# Install
pip install yamllint

# Lint a single file
yamllint config.yaml

# Lint all YAML in a directory
yamllint .

# Output example:
# config.yaml
#   5:1     warning  missing document start "---"  (document-start)
#   12:17   error    trailing spaces  (trailing-spaces)
#   23:3    error    duplication of key "name" in mapping  (key-duplicates)
#   31:1    warning  too many blank lines (3 > 2)  (empty-lines)
#   47:82   warning  line too long (85 > 80 characters)  (line-length)

# .yamllint — project-level yamllint configuration
extends: default

rules:
  # Catch dangerous boolean coercion (YES/NO/ON/OFF as values)
  truthy:
    allowed-values: ['true', 'false']
    check-keys: false   # don't flag truthy-looking keys

  # Catch duplicate keys (silently overwritten)
  key-duplicates: enable

  # Line length — adjust for your team's preference
  line-length:
    max: 120
    allow-non-breakable-words: true

  # Kubernetes manifests don't need document start markers
  document-start: disable

  # Allow multi-document YAML files
  document-end: disable

  # Enforce consistent indentation
  indentation:
    spaces: 2
    indent-sequences: consistent

# Install kubeconform
# macOS: brew install kubeconform
# Go: go install github.com/yannh/kubeconform/cmd/kubeconform@latest

# Validate a single manifest
kubeconform -strict deployment.yaml

# Validate all manifests in a directory
kubeconform -strict k8s/

# Specify Kubernetes version for schema
kubeconform -strict -kubernetes-version 1.29.0 k8s/

# Output as JSON for CI reporting
kubeconform -strict -output json k8s/ | jq '.summary'

# In a GitHub Actions workflow:
# .github/workflows/validate.yml
- name: Validate Kubernetes manifests
  uses: docker://ghcr.io/yannh/kubeconform:latest
  with:
    args: -strict -kubernetes-version 1.29.0 k8s/

# Example output for invalid manifest:
# deployment.yaml - Deployment api-server is invalid:
#   spec.template.spec.containers[0].image: Required value: must have an image

# Render Helm chart and pipe to kubeconform
helm template my-release ./my-chart --values values.yaml   | kubeconform -strict -kubernetes-version 1.29.0 -

# With kubeval (older approach, still common):
# helm template my-release ./my-chart | kubeval --strict --ignore-missing-schemas

# .pre-commit-config.yaml
repos:
  # YAML syntax and style linting
  - repo: https://github.com/adrienverge/yamllint
    rev: v1.35.1
    hooks:
      - id: yamllint
        args: [-c=.yamllint]

  # Kubernetes manifest validation
  - repo: https://github.com/yannh/kubeconform
    rev: v0.6.4
    hooks:
      - id: kubeconform
        args:
          - -strict
          - -kubernetes-version=1.29.0

# Install: pip install pre-commit && pre-commit install
# Run manually: pre-commit run --all-files

# .github/workflows/validate-yaml.yml
name: Validate YAML

on:
  pull_request:
    paths: ['**.yaml', '**.yml', 'k8s/**']

jobs:
  yaml-lint:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4

      - name: Lint YAML files
        uses: ibiqlik/action-yamllint@v3
        with:
          config_file: .yamllint
          file_or_dir: .
          strict: true  # fail on warnings too

  k8s-validate:
    runs-on: ubuntu-latest
    needs: yaml-lint
    steps:
      - uses: actions/checkout@v4

      - name: Validate Kubernetes manifests
        run: |
          curl -sLo kubeconform.tar.gz https://github.com/yannh/kubeconform/releases/latest/download/kubeconform-linux-amd64.tar.gz
          tar xf kubeconform.tar.gz
          ./kubeconform -strict -kubernetes-version 1.29.0 k8s/

package main

import (
    "fmt"
    "os"

    "gopkg.in/yaml.v3"
)

type Config struct {
    Server   ServerConfig   `yaml:"server"`
    Database DatabaseConfig `yaml:"database"`
    LogLevel string         `yaml:"log_level"`
}

type ServerConfig struct {
    Port    int    `yaml:"port"`
    Host    string `yaml:"host"`
    Timeout int    `yaml:"timeout_seconds"`
}

type DatabaseConfig struct {
    URL         string `yaml:"url"`
    MaxConns    int    `yaml:"max_connections"`
    SSLMode     string `yaml:"ssl_mode"`
}

func LoadConfig(path string) (*Config, error) {
    data, err := os.ReadFile(path)
    if err != nil {
        return nil, fmt.Errorf("read config: %w", err)
    }

    dec := yaml.NewDecoder(bytes.NewReader(data))
    dec.KnownFields(true)  // error on unknown fields

    var cfg Config
    if err := dec.Decode(&cfg); err != nil {
        return nil, fmt.Errorf("parse config: %w", err)
    }

    // Additional business-logic validation
    if cfg.Server.Port < 1 || cfg.Server.Port > 65535 {
        return nil, fmt.Errorf("server.port must be 1-65535, got %d", cfg.Server.Port)
    }
    if cfg.Database.MaxConns < 1 {
        return nil, fmt.Errorf("database.max_connections must be >= 1")
    }

    return &cfg, nil
}