YAML JSON Configuration
Developer EssentialsFoundationalFree

YAML JSON Configuration

The course teaches practical JSON and YAML skills for developers, covering data types, nested structures, jq and yq querying, JSON Schema validation, YAML anchors and merge keys, format conversion, and environment-aware configuration management patterns for real-world software projects.

Who Should Take This

Software engineers, DevOps practitioners, and platform engineers who regularly read and write configuration files for CI/CD pipelines, API integrations, Docker Compose, Kubernetes manifests, and application configuration — and want to do it reliably with proper tooling and validation.

What's Covered

1JSON Fundamentals
2YAML Fundamentals
3YAML Querying with yq
4Configuration Management Patterns
5Tooling and Integration

What's Included in AccelaStudy® AI

Adaptive Knowledge Graph
Practice Questions
Lesson Modules
Console Simulator Labs
Exam Tips & Strategy
13 Activity Formats

Course Outline

1JSON Fundamentals
4 topics

JSON Data Types and Syntax

  • Identify the six JSON value types: string, number, boolean, null, array, and object and describe their literal syntax including Unicode escape sequences in strings
  • Implement valid JSON documents with nested objects and arrays including proper comma rules, double-quoted keys, and the prohibition on trailing commas and comments
  • Analyze common JSON syntax errors including unquoted keys, single quotes, trailing commas, and missing commas and debug them using python -m json.tool error output
  • Implement JSON with python -m json.tool for pretty-printing and syntax validation and use --indent flag to control output indentation level

JSON Querying with jq

  • Describe the jq identity filter (.) and field access (.field, .field.nested, .[]) and explain how jq reads JSON from stdin or a file argument
  • Implement jq filters using pipe (|), array iteration (.[] ), map, select, has, keys, values, length, and type to extract and transform JSON data
  • Implement jq pipelines combining multiple filters to reshape API responses including constructing new objects with {key: .expr} syntax and using @base64 and @csv builtins
  • Evaluate when to use jq versus Python json module versus grep for JSON processing based on complexity, portability, and data volume

JSON Schema Validation

  • Describe JSON Schema draft-07 core keywords: type, properties, required, additionalProperties, items, enum, const, minimum, maximum, minLength, maxLength, pattern
  • Implement JSON Schema definitions for configuration objects with nested required fields, array item constraints, and string pattern validation
  • Implement schema validation using the Python jsonschema library to validate configuration files against a schema and report structured error messages

Python json Module

  • Describe the Python json module functions json.loads, json.dumps, json.load, and json.dump and their parameters including indent, sort_keys, ensure_ascii, and default callable
  • Implement JSON serialization with custom encoding using a default() callback to handle datetime objects, Decimal, and other types not serializable by the default encoder
  • Analyze JSON serialization performance trade-offs and evaluate the use of json.JSONDecoder with parse_float=Decimal to preserve numeric precision in financial data
2YAML Fundamentals
4 topics

YAML Data Types and Syntax

  • Identify YAML scalar types including strings, integers, floats, booleans (true/false), null, and date values and describe YAML's implicit type coercion rules
  • Implement YAML mappings (key: value pairs) and sequences (- items) using both block style and flow style ({}, []) and explain indentation rules
  • Analyze YAML implicit type coercion pitfalls where unquoted values like 'yes', 'no', 'on', 'off', 'true', 'false', and version strings get misinterpreted

Multi-Line Strings

  • Describe the difference between literal block scalar (|) which preserves newlines and folded block scalar (>) which folds newlines to spaces
  • Implement literal block (|) and folded (>) scalars with chomping indicators (|- strip, |+ keep) to control trailing newline behavior in configuration values
  • Evaluate when to use literal block style versus folded style versus quoted strings for multi-line configuration values including scripts, SQL queries, and prose

Anchors, Aliases, and Merge Keys

  • Describe YAML anchor (&name) and alias (*name) syntax for reusing node values and explain how aliases create references rather than copies
  • Implement anchors and aliases for shared configuration blocks like database connection settings and explain how modifying an anchor affects all aliases
  • Implement YAML merge key operator (<<: *anchor) to inherit and override mapping fields from anchored templates for DRY configuration patterns
  • Analyze the limitations of YAML anchors including inability to merge sequences, cross-document references, and tooling support differences between PyYAML and ruamel.yaml

YAML Documents and Python PyYAML

  • Describe YAML document markers (--- start, ... end) for multi-document YAML streams and explain how they enable multiple independent documents in a single file
  • Implement YAML parsing with Python PyYAML using yaml.safe_load for untrusted input and yaml.safe_load_all for multi-document streams and explain why safe_load is preferred over yaml.load
  • Implement YAML output with PyYAML yaml.dump using default_flow_style=False for block style and sort_keys=False to preserve insertion order
  • Evaluate the security risks of YAML deserialization with yaml.load() and the arbitrary code execution risk from custom tags and explain why yaml.safe_load is non-negotiable for user input
3YAML Querying with yq
3 topics

yq Basics

  • Describe the yq command-line tool (mikefarah/yq v4) and its jq-compatible filter syntax for querying and updating YAML files in-place
  • Implement yq queries to extract nested values (.spec.template.spec.containers[0].image), update fields in-place (yq -i), and filter sequences using select()
  • Implement yq operations for merging YAML files, deleting keys, and converting between YAML and JSON output using yq -o=json and yq -o=yaml flags

Format Conversion

  • Implement YAML-to-JSON conversion using yq and Python PyYAML/json modules and describe data fidelity issues including YAML tags and anchor resolution
  • Implement JSON-to-YAML conversion and analyze which JSON values require quoting in YAML output to prevent type coercion errors
  • Evaluate round-trip fidelity when converting between JSON and YAML and identify data types that cannot survive conversion without data loss

Advanced jq Patterns

  • Implement jq reduce, to_entries, from_entries, and with_entries patterns to transform object keys and aggregate array values into computed summaries
  • Implement jq env and $ENV to access environment variables inside filters and use --arg and --argjson to pass shell variables into jq filters safely
  • Evaluate jq paths, del, and set (.key = value) operations for surgical modification of deeply nested JSON and compare to Python dict manipulation for maintainability
4Configuration Management Patterns
5 topics

Environment-Aware Configuration

  • Describe patterns for environment-specific configuration including separate config files per environment, environment variable substitution, and overlay/override strategies
  • Implement a base configuration YAML file and environment-specific override files (config.base.yaml, config.dev.yaml, config.prod.yaml) using deep merge logic
  • Analyze security implications of storing secrets in configuration files versus environment variables versus secret managers and evaluate .gitignore strategies

Merging and Deep Merging

  • Describe shallow merge versus deep merge behavior for nested configuration objects and explain how array merging strategies (replace, append, merge-by-key) differ
  • Implement deep merge of two YAML configuration objects using Python with a recursive merge function that handles nested dicts and list concatenation
  • Evaluate configuration merge strategies for CI/CD pipeline YAML files and analyze how GitHub Actions and Docker Compose handle service/step inheritance

Building Application Config from Scratch

  • Identify the key sections of a complete application configuration file: database connections, server settings, feature flags, logging config, and third-party integrations
  • Implement a complete application configuration YAML file with anchors for shared values, environment-specific sections, and a matching JSON Schema for validation
  • Evaluate a given application configuration for completeness, security hygiene, DRY violations, and validate it against its JSON Schema reporting actionable error messages

Real-World Config Formats

  • Describe the structure of common YAML configuration formats including GitHub Actions workflows, Docker Compose files, and OpenAPI specification documents
  • Implement a GitHub Actions workflow YAML with multiple jobs, steps using anchors for shared env vars, and a matrix strategy for multi-version testing
  • Analyze Docker Compose service definition YAML for correct volume mounts, network references, dependency ordering with depends_on, and environment variable injection

Advanced JSON Schema Features

  • Describe JSON Schema composition keywords: anyOf, oneOf, allOf, not and explain how they combine schemas for union types, conditional validation, and exclusion
  • Implement JSON Schema $ref to reuse schema definitions and use $defs to define and reference component schemas for common data types across a configuration spec
  • Implement conditional schema validation using if/then/else to apply different property requirements based on the value of a discriminator field
  • Evaluate JSON Schema limitations for expressing complex business rules and analyze when to supplement schema validation with custom Python validation logic
5Tooling and Integration
3 topics

Config File Discovery and Loading

  • Describe common configuration file search conventions including XDG_CONFIG_HOME, home directory dotfiles, and project-local config files with environment variable overrides
  • Implement a Python configuration loader that searches multiple locations in priority order, merges found configs, and applies environment variable overrides
  • Evaluate configuration loading strategies for twelve-factor apps that favor environment variables over config files and analyze how to bridge both approaches

Linting and Formatting

  • Identify YAML linting tools (yamllint) and their common rules for indentation consistency, trailing spaces, line length, and duplicate keys
  • Implement yamllint configuration using a .yamllint file to enforce project-specific rules and integrate it into a pre-commit hook for automated YAML validation
  • Evaluate JSON and YAML formatting tools (Prettier, yq, jq) for their ability to enforce consistent style across a codebase and their CI integration options

Config Diff and Version Control

  • Implement jq-based diff comparison between two JSON config versions to identify changed, added, and removed fields across environment upgrades
  • Analyze strategies for tracking configuration changes in git including JSON normalization before committing to produce clean diffs and YAML comment preservation challenges

Scope

Included Topics

  • JSON data types (strings, numbers, booleans, null, arrays, objects), JSON formatting and validation with python -m json.tool and jq, YAML scalars (strings, numbers, booleans, null), mappings, sequences, multi-line strings (literal block |, folded >), YAML anchors and aliases (&, *, <<), YAML merge keys, schema validation with jsonschema Python library, YAML and JSON querying with jq and yq, format conversion between JSON and YAML, environment-specific configuration management, merging and overriding configuration values

Not Covered

  • TOML and INI configuration formats
  • XML and XML Schema validation
  • JSON5 and HJSON non-standard formats
  • GraphQL SDL schema language
  • Protocol Buffers and Avro schemas
  • Configuration management tools (Ansible, Puppet, Chef)
  • Kubernetes manifest authoring beyond YAML fundamentals

Start YAML JSON Configuration — free

Adaptive learning that maps what you already know and closes the gaps. No credit card, no trial clock, no paywall.

Enroll Free

More free Developer Essentials courses