Yaml Cheat Sheet

parent:
  child: value
  another_child: value

# This is a comment
key: value  # This is an inline comment

key: value
server: apache
port: 80

Name: John
name: john    # These are different keys

unquoted: Hello World
single_quoted: 'Hello World'
double_quoted: "Hello World"

integer: 42
float: 3.14159
scientific: 12.3015e+05
octal: 0o14  # = 12 decimal
hex: 0xC     # = 12 decimal
infinity: .inf
negative_infinity: -.inf
not_a_number: .nan

boolean_true: true   # Also True, TRUE, yes, Yes, YES, on, On, ON
boolean_false: false # Also False, FALSE, no, No, NO, off, Off, OFF

null_value: null   # Also Null, NULL, ~, or simply nothing
explicit_null: ~
empty: 
key_with_no_value:

fruits:
  - Apple
  - Banana
  - Orange

fruits: [Apple, Banana, Orange]

person:
  name: John Doe
  age: 30
  languages:
    - Python
    - JavaScript

person: {name: John Doe, age: 30, languages: [Python, JavaScript]}

departments:
  - name: Engineering
    employees:
      - name: Alice
        role: Developer
      - name: Bob
        role: DevOps
  - name: Marketing
    employees:
      - name: Charlie
        role: Content Writer

base: &base
  name: Base Config
  timeout: 60
  retries: 5

development:
  <<: *base   # Merges the base anchor
  environment: development
  debug: true

production:
  <<: *base   # Merges the base anchor
  environment: production
  debug: false

defaults: &defaults
  timeout: 30
  logging: true

testing:
  <<: *defaults
  timeout: 10  # This value overrides the one from defaults

common: &common
  version: 1.0
  api_key: abc123

logging: &logging
  log_level: info
  log_format: json

config:
  <<: [*common, *logging]  # Merge multiple anchors
  environment: production

name: John Doe
job: "Software Engineer"

age: 30
year: 2023

pi: 3.14159
gravity: 9.81

active: true
disabled: false

value: null
empty: ~

created: 2023-01-15T12:30:45+00:00
date: 2023-01-15

gif_file: !!binary |
  R0lGODlhDAAMAIQAAP//9/X17unp5WZmZgAAAOfn515eXvPz7Y6OjuDg4J+fn5
  OTk6enp56enmleECcgggoBADs=

fruits: !!set
  ? apple
  ? banana
  ? orange

description: |
  This is a multi-line string.
  Line breaks are preserved.
  Indentation is stripped.
    Extra indentation is preserved.

description: >
  This is a multi-line string.
  Line breaks become spaces.

  Empty lines create line breaks.

text: |+
  This text has trailing line breaks.


# The three empty lines above are preserved

text: |-
  This text has no trailing line breaks.


# No line breaks are preserved

code: |2
    def hello():
      print("Hello, world!")
  
  # The function is indented by 4 spaces, and 2 spaces are stripped

single_quote: 'It''s a nice day'
double_quote: "She said, \"Hello!\""

windows_path: "C:\\Program Files\\App"
windows_path_literal: 'C:\Program Files\App'

newline: "Line 1\nLine 2"
tab: "Column 1\tColumn 2"
unicode: "Pi: \u03C0"

valid: http://example.com  # Space after colon in URL
invalid_without_quotes: http://example.com:8080  # Would need quotes
valid_with_quotes: "http://example.com:8080"

numeric_string: "123"  # Quoted to ensure it's a string, not a number
boolean_like: "yes"    # Quoted to prevent parsing as boolean true
null_like: "null"      # Quoted to prevent parsing as null

---
# Document content starts here
key: value

key: value
# Document content ends here
...

---
# First document
name: Document 1
---
# Second document
name: Document 2
---
# Third document
name: Document 3
...

%YAML 1.2
---
# Document with YAML 1.2 directive

company:
  name: Example Corp
  departments:
    - name: Engineering
      employees:
        - name: Alice
          skills:
            - Python
            - Kubernetes
        - name: Bob
          skills:
            - Go
            - AWS
    - name: Marketing
      employees:
        - name: Charlie
          campaigns:
            q1:
              budget: 50000
              channels: [Social, Email]
            q2:
              budget: 65000
              channels: [Social, PPC]

? - Manchester United
  - Chelsea
: 2-0
? - Barcelona
  - Real Madrid
: 3-2

defaults: &defaults
  port: 80
  timeout: 60
  retries: 3

development:
  <<: *defaults
  host: dev.example.com
  debug: true

production:
  <<: *defaults
  host: prod.example.com
  timeout: 30  # Override specific value
  tls: true    # Add new value

servers:
  - name: server1
    config: {port: 8080, protocol: http}
    roles: [api, web]
  - name: server2
    config:
      port: 8443
      protocol: https
    roles:
      - database
      - cache

number_as_string: !!str 123
boolean_as_string: !!str true

integer: !!int 42
string_to_int: !!int "42"

float: !!float 3.14
integer_to_float: !!float 42  # Becomes 42.0

bool_from_string: !!bool "true"  # Becomes true
bool_from_number: !!bool 1       # Becomes true
bool_from_zero: !!bool 0         # Becomes false

null_value: !!null
explicit_null: !!null "null"  # Still null

empty_list: !!seq {}
single_value_list: !!seq 1       # Becomes [1]
string_to_chars: !!seq "abc"     # Becomes ['a', 'b', 'c']

empty_map: !!map []
pairs_to_map: !!map [[key1, val1], [key2, val2]]

binary_data: !!binary |
  R0lGODlhDAAMAIQAAP//9/X17unp5WZmZgAAAOfn515eXvPz7Y6OjuDg4J+fn5
  OTk6enp56enmleECcgggoBADs=

iso_datetime: !!timestamp 2023-01-15T12:30:45+00:00
iso_date: !!timestamp 2023-01-15

unique_items: !!set
  ? apple
  ? banana
  ? apple  # Duplicate, will only appear once

ordered: !!omap
  - first: 1
  - second: 2
  - third: 3

%TAG !local! !my-app/
---
# Now !local! will be expanded to !my-app/
person: !local!person
  name: John
  age: 30

%TAG !yaml! tag:yaml.org,2002:
---
# Using globally defined tags
integers: !yaml!int [1, 2, 3]

configuration: !config
  environment: production
  features:
    - !feature
      name: dark-mode
      enabled: true
    - !feature
      name: analytics
      enabled: false

%TAG !e! tag:example.com,2023:
---
# This:
value: !e!type {}
# Is equivalent to:
value: !tag:example.com,2023:type {}

%YAML 1.2
---
# This document uses YAML 1.2

%TAG !yaml! tag:yaml.org,2002:
%TAG !app! tag:myapplication.com,2023:
---
numbers: !yaml!seq [1, 2, 3]
user: !app!user
  name: John

%YAML 1.2
%TAG !yaml! tag:yaml.org,2002:
--- # Directive end marker
# Document content starts here

# Good
parent:
  child1: value
  child2:
    grandchild: value

# Avoid inconsistent indentation
parent:
 child1: value
   child2:
  grandchild: value

# Good (quoted to avoid misinterpretation)
message: "Error: file not found"
empty_string: ""
numeric_string: "123"

# Problematic (could be misinterpreted)
message: Error: file not found  # Colons need care
empty_string:  # This is a null, not an empty string
numeric_string: 123  # This is a number, not a string

---
# First configuration
environment: development
---
# Second configuration
environment: production
...

# Database connection settings
database:
  host: localhost
  port: 5432  # Default PostgreSQL port
  credentials:
    # Use environment variables in production
    username: ${DB_USER:-postgres}
    password: ${DB_PASS:-admin}

# Define defaults once
defaults: &defaults
  timeout: 30
  retries: 3
  logging: true

# Reuse with overrides
service1:
  <<: *defaults
  name: auth-service

service2:
  <<: *defaults
  name: data-service
  timeout: 60  # Override specific setting

# Use tools like yamllint, kwalify, or JSON Schema
# to validate your YAML files against a defined schema

# Example command:
# yamllint config.yaml
# jsonschema -i config.yaml schema.json

# Always use spaces (usually 2) for indentation
# Many editors can be configured to insert spaces when tab is pressed

# Ensure all indentation is consistent, typically 2 spaces
# Use an editor with YAML support and indentation guides

# Bad - will be parsed incorrectly
special: Hello: World

# Good - quoted to handle the colon
special: "Hello: World"

# Incorrect - wrong chomping indicator
description: |+
  First line.
  Second line.
third_key: value  # This might not work as expected

# Correct
description: |
  First line.
  Second line.
third_key: value

# Ambiguous - numeric-looking string
zip: 02138  # Will be interpreted as an integer

# Clear - explicitly quoted
zip: "02138"  # Will be a string

# Will be parsed as boolean true
status: yes

# Use quotes for string values
status: "yes"

# Error - referencing a non-existent anchor
settings: *base  # base is not defined anywhere

# Correct
base: &base
  timeout: 30
settings: *base

base: &base
  name: John Doe
  age: 30

user:
  <<: *base
  role: admin  # Additional key
  age: 31      # Override existing key

? - key1
  - key2
: value

# Equivalent to:
{[key1, key2]: value}

canonical: !!str 2001-12-15
integer: !!int 3
float: !!float 3.14
boolean: !!bool true
null: !!null null
datetime: !!timestamp 2001-12-15T02:59:43.1Z

# Set with unique values
set: !!set
  ? item1
  ? item2
  ? item1  # Duplicate, will be ignored

# Ordered map
ordered_map: !!omap
  - key1: value1
  - key2: value2
  # Order is preserved

%TAG !myapp! tag:example.com,2023:app/
---
# This expands to !tag:example.com,2023:app/User
config: !myapp!User
  name: John

# Rich type system
- strings
- numbers
- booleans
- null
- timestamps
- binary
- sets
- more complex types

// Limited type system
- strings
- numbers
- booleans
- null
- arrays
- objects

# Multiple ways to represent data
# Block style
items:
  - item1
  - item2

# Flow style
items: [item1, item2]

// One strict syntax
{
  "items": [
    "item1",
    "item2"
  ]
}

# DRY with anchors and aliases
base: &base
  key: value
  
extended:
  <<: *base
  extra: value

// No native support for references
// Requires repetition or custom processing

# Native multiline support
description: |
  This is a multi-line
  description that preserves
  line breaks.

// No native multiline
// Requires escape characters
{
  "description": "This is a multi-line\ndescription that uses\nescape characters."
}

# Valid JSON is valid YAML 1.2
{"key": "value"}

// YAML must be converted to be valid JSON

# Server configuration
server:
  host: localhost
  port: 8080
  debug: true
  
database:
  driver: postgres
  host: db.example.com
  credentials:
    username: admin
    password: ${DB_PASSWORD}  # Environment variable

apiVersion: apps/v1
kind: Deployment
metadata:
  name: nginx-deployment
  labels:
    app: nginx
spec:
  replicas: 3
  selector:
    matchLabels:
      app: nginx
  template:
    metadata:
      labels:
        app: nginx
    spec:
      containers:
      - name: nginx
        image: nginx:1.14.2
        ports:
        - containerPort: 80

name: CI Pipeline

on:
  push:
    branches: [main]
  pull_request:
    branches: [main]

jobs:
  build:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v3
      - name: Set up Node.js
        uses: actions/setup-node@v3
        with:
          node-version: '16'
      - name: Install dependencies
        run: npm ci
      - name: Run tests
        run: npm test

version: '3'
services:
  web:
    image: nginx:alpine
    ports:
      - "80:80"
    volumes:
      - ./site:/usr/share/nginx/html
    depends_on:
      - api
  api:
    build: ./api
    environment:
      - NODE_ENV=production
      - DB_HOST=db
    ports:
      - "3000:3000"
  db:
    image: postgres:13
    volumes:
      - postgres_data:/var/lib/postgresql/data
    environment:
      - POSTGRES_PASSWORD=secret
      - POSTGRES_USER=app

volumes:
  postgres_data:

# Terminal command
$ yamllint config.yaml

# Configuration file (.yamllint)
rules:
  line-length: {max: 100}
  indentation: {spaces: 2}
  document-start: disable

# Extract a value
$ yq '.server.port' config.yaml

# Update a value
$ yq '.server.port = 8080' -i config.yaml

# Convert YAML to JSON
$ yq -o=json . config.yaml

# Python code
import yaml

# Load YAML from file
with open('config.yaml', 'r') as file:
    config = yaml.safe_load(file)

# Modify data
config['server']['port'] = 8080

# Save YAML to file
with open('config.yaml', 'w') as file:
    yaml.dump(config, file, default_flow_style=False)

// JavaScript code
const yaml = require('js-yaml');
const fs = require('fs');

// Load YAML from file
const config = yaml.load(fs.readFileSync('config.yaml', 'utf8'));

// Modify data
config.server.port = 8080;

// Save YAML to file
fs.writeFileSync('config.yaml', yaml.dump(config));

# Compare two YAML files
$ yamldiff file1.yaml file2.yaml

# Popular online validators:
- YAML Lint (yamllint.com)
- Online YAML Parser (onlineyamltools.com)
- JSON to YAML converter (json2yaml.com)

- Initial YAML specification
- Complex and less standardized
- More permissive

- Added many data types (timestamps, binary, etc.)
- Octal numbers with leading 0 (e.g., 010 = 8)
- More flexible handling of Boolean values
- Support for various formats of null

- JSON compatibility: all JSON is valid YAML 1.2
- Changed octal notation (0o10 instead of 010)
- Restricted Boolean values to true/false, yes/no, on/off
- Simplified specification
- Multiple document streams
- Improved Unicode support

- Clarified several aspects of the specification
- Fixed inconsistencies
- Better documentation
- Still backward compatible with YAML 1.2

# VULNERABLE:
yaml.load(user_input)  # Full YAML, allows code execution

# SAFE:
yaml.safe_load(user_input)  # Restricted YAML, safer

# Set limits on entity expansions in your YAML parser
# Use safest parsing mode available

# For PyYAML:
yaml.safe_load(content)

# BAD: Hard-coded secrets
api_key: "1234abcd"

# BETTER: Environment variables
api_key: ${API_KEY}

# BEST: Use proper secret management
# Like HashiCorp Vault, AWS Secrets Manager, etc.

# Restrict file operations when parsing YAML
# Ensure proper path validation
# Disable unnecessary YAML features that allow file access

# Set size limits for YAML content
# Timeout for parsing operations
# Limit recursion depth in nested structures

# Specify encoding when reading/writing YAML files
# Python example:
with open('file.yaml', 'r', encoding='utf-8') as file:
    data = yaml.safe_load(file)

# Node.js example:
fs.readFileSync('file.yaml', 'utf8')

# Direct Unicode characters
greeting: "¡Hola, mundo!"
language: "日本語"
symbol: "∞"

# Unicode escapes in double quotes
escaped: "\u00A9 2023"  # © 2023

# YAML spec recommends against BOM in UTF-8
# But some parsers handle it properly

# To remove BOM with Python:
with open('file.yaml', 'r', encoding='utf-8-sig') as file:
    data = yaml.safe_load(file)

# Unicode in keys
价格: 100  # "price" in Chinese
språk: "Norwegian"  # "language" in Norwegian

# Unicode in anchors
基本: &基本  # "basic" in Chinese
  name: Value
引用: *基本  # Reference to the anchor

database:
  host: ${DB_HOST:-localhost}  # Use DB_HOST or default to localhost
  port: ${DB_PORT:-5432}
  username: ${DB_USER}
  password: ${DB_PASSWORD}

version: '3'
services:
  web:
    image: nginx
    environment:
      - NODE_ENV=production
      - API_KEY=${API_KEY}  # From host environment

# Using envsubst (Unix command)
$ envsubst < template.yaml > config.yaml

# Template example:
api:
  url: https://$API_DOMAIN
  key: $API_KEY

# Python with python-dotenv + pyyaml + jinja2
import os
import yaml
from dotenv import load_dotenv
from jinja2 import Template

load_dotenv()
with open('template.yaml') as f:
    template = Template(f.read())
    
rendered = template.render(**os.environ)
config = yaml.safe_load(rendered)

# schema.json
{
  "type": "object",
  "required": ["name", "version"],
  "properties": {
    "name": { "type": "string" },
    "version": { "type": "string" },
    "dependencies": {
      "type": "object",
      "additionalProperties": { "type": "string" }
    }
  }
}

# Validation command
$ jsonschema -i package.yaml schema.json

# schema.yaml
type: map
mapping:
  name:
    type: str
    required: true
  version:
    type: str
    pattern: /^\d+\.\d+\.\d+$/
  dependencies:
    type: map
    mapping:
      =:
        type: str

# Validate with kwalify
$ kwalify -f schema.yaml data.yaml

# .yamllint configuration
extends: default
rules:
  line-length: {max: 120}
  indentation: {spaces: 2}
  document-start: disable
  trailing-spaces: enable
  
# Run validation
$ yamllint config.yaml

# Python example with cerberus
import yaml
from cerberus import Validator

schema = {
    'name': {'type': 'string', 'required': True},
    'age': {'type': 'integer', 'min': 0},
    'email': {'type': 'string', 'regex': r'^[^@]+@[^@]+\.[^@]+$'}
}

with open('data.yaml') as f:
    data = yaml.safe_load(f)

v = Validator(schema)
if not v.validate(data):
    print(v.errors)

# This is a multi-line comment
# spanning several lines in YAML.
# Each line needs its own hash symbol.
key: value

_comment: |
  This is a multi-line comment
  that can span several lines.
  The key name can be anything, typically prefixed
  with _ to indicate it's not meant to be processed.

key: value

_: &comment |
  This is a multi-line comment
  that can span several lines.
  It uses an anchor that's never referenced.

key: value

--- |
  This is a comment document
  containing documentation that
  will be parsed but typically ignored
  by most applications.
---
# Actual content
key: value

import yaml

# Load YAML from string
data = yaml.safe_load("""
name: John
age: 30
""")

# Save to file
with open('output.yaml', 'w') as f:
    yaml.dump(data, f, default_flow_style=False)

const yaml = require('js-yaml');
const fs = require('fs');

// Load YAML from file
const data = yaml.load(fs.readFileSync('file.yaml', 'utf8'));

// Convert to YAML string
const yamlStr = yaml.dump(data, {
  lineWidth: -1,
  noRefs: true
});

require 'yaml'

# Load YAML
data = YAML.load_file('file.yaml')

# Convert to YAML
yaml_string = data.to_yaml

# Save to file
File.write('output.yaml', yaml_string)

import org.yaml.snakeyaml.Yaml;
import java.io.FileInputStream;
import java.io.FileWriter;
import java.util.Map;

// Load YAML
Yaml yaml = new Yaml();
Map data = yaml.load(new FileInputStream("file.yaml"));

// Save YAML
FileWriter writer = new FileWriter("output.yaml");
yaml.dump(data, writer);

package main

import (
    "fmt"
    "io/ioutil"
    "log"
    
    "gopkg.in/yaml.v3"
)

type Config struct {
    Name    string   `yaml:"name"`
    Version string   `yaml:"version"`
    Tags    []string `yaml:"tags"`
}

func main() {
    // Read YAML file
    data, err := ioutil.ReadFile("config.yaml")
    if err != nil {
        log.Fatalf("error: %v", err)
    }
    
    // Parse YAML
    var config Config
    err = yaml.Unmarshal(data, &config)
    if err != nil {
        log.Fatalf("error: %v", err)
    }
    
    // Create YAML
    newData, err := yaml.Marshal(&config)
    if err != nil {
        log.Fatalf("error: %v", err)
    }
    
    // Write YAML file
    err = ioutil.WriteFile("output.yaml", newData, 0644)
    if err != nil {
        log.Fatalf("error: %v", err)
    }
}

# Block mapping
person:
  name: John Doe
  age: 30
  languages:
    - Python
    - JavaScript
    - Go

# Block sequence
fruits:
  - apple
  - banana
  - orange

# Flow mapping
person: {name: John Doe, age: 30, languages: [Python, JavaScript, Go]}

# Flow sequence
fruits: [apple, banana, orange]

# Block style for outer structure, flow for simple inner structures
services:
  web:
    ports: [80, 443]
    environment: {NODE_ENV: production, DEBUG: false}
  db:
    ports: [5432]
    volumes:
      - data:/var/lib/postgresql/data

# Use block style for:
# - Complex, deeply nested structures
# - Better readability and maintainability
# - Most configuration files

# Use flow style for:
# - Simple, compact data
# - Single-line entries
# - Compatibility with JSON

content: |
  This is a multi-line
  text block.
  All line breaks are preserved.
next_key: value  # A single newline is preserved after the block

content: >
  This is a multi-line
  text block.
  Line breaks become spaces.

  Blank lines still create paragraphs.
next_key: value  # A single newline is preserved after the block

content: |-
  This is a multi-line
  text block.
  No trailing newlines are kept.


next_key: value  # No blank lines between this and the block

content: |+
  This is a multi-line
  text block.
  All trailing newlines are kept.


next_key: value  # Three blank lines are preserved

content: |2
    This line has 4 spaces of indentation.
    This line also has 4 spaces.
  This line has 2 spaces.
    
# With indentation indicator of 2:
# - 2 spaces are stripped from each line
# - First two lines become indented by 2 spaces
# - Third line has no indentation

content: >2-
    This folded text has
    custom indentation set to 2
    and clip chomping to remove trailing newlines.
next_key: value  # No space between this and the previous block

# These are all treated as boolean true
active: true
active: True
active: TRUE
active: yes
active: Yes
active: YES
active: on
active: On
active: ON

# These are all treated as boolean false
active: false
active: False
active: FALSE
active: no
active: No
active: NO
active: off
active: Off
active: OFF

# PROBLEM: These are converted to boolean values
status: yes    # Becomes true
answer: no     # Becomes false
state: on      # Becomes true

# SOLUTION: Use quotes to force string interpretation
status: "yes"  # Stays as string "yes"
answer: 'no'   # Stays as string "no"
state: "on"    # Stays as string "on"

# YAML 1.1 (more boolean values)
- y      # true
- Y      # true
- yes    # true
- Yes    # true
- YES    # true
- n      # false
- N      # false
- no     # false
- No     # false
- NO     # false

# YAML 1.2 (more restricted)
# Only these are standardized:
- true   # true
- True   # true
- false  # false
- False  # false

# All these are boolean true
enabled: true
enabled: True
enabled: TRUE

# To use case-sensitive words that look like booleans:
value: "True"    # String "True"
title: 'Yes'     # String "Yes"

# JSON Schema example
{
  "properties": {
    "enabled": {
      "type": "boolean"
    },
    "status": {
      "type": "string",
      "enum": ["yes", "no", "maybe"]
    }
  }
}