Wat is YAML? De basis, syntaxis en gebruiksscenario’s uitgelegd

Door de jaren heen heb ik met talloze configuratiebestanden gewerkt, en YAML sprong eruit door zijn eenvoud en leesbaarheid. Of je nu workflows in Kubernetes opzet, services in Docker definieert of API-verzoeken structureert, met YAML worden complexe configuraties beter beheersbaar. De schone, op inspringing gebaseerde structuur haalt de rommel weg die je bij formaten als XML ziet, terwijl het toch flexibel blijft.

In deze gids neem ik je mee door de syntaxis, structuur, geavanceerde features en best practices van YAML, zodat je er met vertrouwen mee kunt werken. 

Wat is YAML?

YAML (Yet Another Markup Language / YAML Ain’t Markup Language) is een gegevensserialisatieformaat dat leesbaarheid en gebruiksgemak vooropstelt. Terwijl XML met HTML-achtige geneste tags werkt en JSON met accolades en aanhalingstekens (zoals Python-dictionaries), is YAML compacter en gebruikt het inspringing om structuur te definiëren, wat het mensvriendelijker maakt.

YAML ondersteunt verschillende gegevenstypen, waaronder scalars (strings, getallen, booleans), sequenties (lijsten) en mappings (sleutel-waardeparen). Het wordt veel gebruikt in configuratiebestanden, infrastructuurautomatisering en gegevensuitwisseling, vooral in tools als Kubernetes, Docker en Ansible.

Daarnaast is YAML een superset van JSON, wat betekent dat geldige JSON-bestanden als YAML kunnen worden geparseerd. YAML-bestanden hebben doorgaans de extensie .yaml of .yml.

Je kunt ook meer over YAML leren op de website.

YAML-syntaxis en -structuur

In dit onderdeel bekijken we de basisprincipes van de YAML-syntaxis, waaronder sleutel-waardeparen, lijsten, geneste data en commentaar.

Basis syntaxisregels

Er zijn een paar basisregels voor YAML: 

• Spatie-inspringing bepaalt de structuur, dus vermijd tabs! 
• Sleutel-waardeparen volgen een key: value-structuur, vergelijkbaar met andere talen. 
• Streepjes aan het begin van regels geven een lijst aan. 
• Met # maak je commentaarregels.

# Here is an example of YAML
name: John Doe
age: 30
skills:
  - Python
  - YAML

Sleutel-waardeparen

YAML stelt data voor als sleutel-waardeparen, vergelijkbaar met dictionaries in Python. Dit geeft vaak informatie door aan verschillende configuratiebestanden en instellingen. Je hoeft strings of sleutels niet tussen aanhalingstekens te zetten; schrijf gewoon de benodigde sleutel en waarden:

location: New York
country: USA
security-level: user

Lijsten in YAML

Lijsten worden weergegeven met streepjes (-). Hiermee kun je meerdere objecten onder één sleutel groeperen. In markup-editors worden die visueel vaak als opsommingstekens getoond.

fruits:
  - Apple
  - Banana
  - Cherry

Geneste data

Geneste structuren maken hiërarchische datarepresentatie mogelijk via inspringing. Denk hieraan als geneste dictionaries. Door in te springen geef je aan welke sleutels subsets van andere sleutels zijn.

person:
  name: Alice
  details:
    age: 25
    city: London

Commentaar

Commentaar begint met # en wordt genegeerd door YAML-parsers. Dit zijn commentaar op één regel.

# This is a comment
username: admin
password: secret

Geavanceerde YAML-features

YAML bevat krachtige features zoals meerregelige strings, gegevenstypen en anchors, die documenten efficiënter en beter gestructureerd maken. In dit onderdeel verkennen we deze mogelijkheden met praktische voorbeelden.

Meerregelige strings

YAML ondersteunt meerregelige strings met | (letterlijk blok) of > (gevouwen blok). 

• Het |-letterlijk blok maakt een nieuwe regel \n voor elke regeleinde. 
• Het >-gevouwen blok maakt alleen een nieuwe regel bij opeenvolgende regeleinden.

literal: |
  This is a
  multi-line string.

folded: >
  This is another
  multi-line string.

Het bovenstaande wordt duidelijker met de output erbij.

• Voor het | (letterlijk blok):

This is a
multi-line string.

• Voor het > (gevouwen blok):

This is another multi-line string.

Gegevenstypen in YAML

YAML ondersteunt verschillende gegevenstypen, waaronder strings, getallen, booleans en null-waarden. Het detecteert typen automatisch op basis van de opmaak, maar staat ook expliciete typedefinities toe.

Het volgende voorbeeld laat het gebruik van basistypen in YAML zien:

string_implicit: Hello, YAML!  # No quotes needed unless necessary
string_double_quoted: "Supports escape sequences like \n and \t"
string_single_quoted: 'Raw text, no escape sequences'

integer: 42  # Whole numbers
float: 3.14  # Numbers with decimals

boolean_true: true
boolean_false: false

null_value: null  # Null value
null_tilde: ~  # Another way to represent null

YAML staat expliciete typedefinities toe met !!type wanneer dat nodig is:

explicit_string: !!str 123  # Forces 123 to be a string
explicit_integer: !!int "42"  # Forces "42" to be an integer
explicit_float: !!float "3.14"  # Forces "3.14" to be a float

Omdat YAML vaak voor gestructureerde data wordt gebruikt, ondersteunt het:

• Lijsten (sequenties):

fruits:
  - Apple
  - Banana
  - Cherry

• Dictionaries (mappings):

person:
  name: Alice
  age: 30
  is_student: false

Anchors en aliassen

YAML laat je herbruikbare waarden definiëren met anchors (&) en ze later refereren met aliassen (*). Dit helpt herhaling te verminderen in configuratiebestanden, waardoor ze overzichtelijker en onderhoudsvriendelijker worden.

defaults: &default_settings
  retries: 3
  timeout: 30

server1:
  host: example.com
  retries: *default_settings  # Reuses the retries value from defaults

De <<:-syntaxis laat je sleutel-waardeparen uit een anchor samenvoegen in een andere mapping. Als een sleutel in beide voorkomt, overschrijft de nieuwe waarde de oorspronkelijke.

defaults: &default_settings
  retries: 3
  timeout: 30

server1:
  <<: *default_settings  # Merges all key-value pairs from default_settings
  host: example.com  # This key is added to the merged data

Dit is de uiteindelijke, opgeloste structuur:

server1:
  retries: 3
  timeout: 30
  host: example.com

Anchors en aliassen zijn vooral handig in grote configuratiebestanden waar waarden herhalen inefficiënt zou zijn. Ze helpen YAML-bestanden DRY te houden (Don't Repeat Yourself) en maken updates eenvoudiger.

Veelvoorkomende gebruiksscenario’s voor YAML

YAML wordt veel gebruikt in softwareontwikkeling, infrastructuurautomatisering en API-beheer. Dankzij de mensvriendelijke syntaxis is het een voorkeursformaat voor configuratiebestanden, gegevensserialisatie en Infrastructure as Code (IaC). Laten we de meest voorkomende toepassingen bekijken.

Configuratiebestanden

YAML wordt veel gebruikt voor configuratie in applicaties zoals Docker Compose, Kubernetes en CI/CD-pipelines. Doordat het zo begrijpelijk is, kan eigenlijk iedereen Docker YAML-setupbestanden oppakken en zien wat er gebeurt.

version: '3'
services:
  web:
    image: nginx
    ports:
      - "80:80"
    environment:
      - NGINX_HOST=localhost
      - NGINX_PORT=80

De leesbaarheid van YAML en de ondersteuning voor anchors en aliassen helpen herhaling te verminderen, waardoor het onderhoudsvriendelijker is dan JSON of XML.

Leer meer over YAML en het gebruik ervan in Docker in tze middelgevorderde Docker-cursus.

Serialisatie en overdracht van data

YAML wordt gebruikt om data te serialiseren voor API’s en configuratiebeheertools door complexe datastructuren om te zetten naar een mensleesbaar formaat dat ook eenvoudig door machines te parsen is. 

Bijvoorbeeld, een API-request body geformatteerd in YAML:

user:
  id: 123
  name: "John Doe"
  email: "johndoe@example.com"
  active: true

De op inspringing gebaseerde structuur van YAML haalt overbodige syntaxis weg, waardoor het lichter, leesbaar en makkelijk te wijzigen is vergeleken met JSON.

Infrastructure as Code (IaC)

Configuratiebeheertools zoals Ansible en Kubernetes gebruiken YAML om systeemtoestanden te definiëren, processen te automatiseren en consistentie over omgevingen te waarborgen.

• In Ansible wordt YAML gebruikt om playbooks te schrijven die systeemtoestanden, taken en dependencies definiëren, zodat infrastructuuronderdelen consistent geconfigureerd zijn. 
• Kubernetes gebruikt YAML-manifests om resources zoals pods, services en deployments te definiëren, waardoor geautomatiseerde orkestratie van gecontaineriseerde applicaties mogelijk wordt.

Hier is een voorbeeld van een Kubernetes Pod-configuratie:

apiVersion: v1
kind: Pod
metadata:
  name: my-app
spec:
  containers:
    - name: app-container
      image: my-app:latest
      ports:
        - containerPort: 8080

Leer meer over hoe YAML wordt gebruikt in Kubernetes in deze Introduction to Kubernetes-cursus.

API-documentatie

API-specificaties zoals OpenAPI en Swagger gebruiken YAML om endpoints en datastructuren op een leesbare manier te definiëren. Met YAML worden API-methoden, requestparameters, responseformaten en authenticatiemethoden beschreven.

Hier is een voorbeeld van een OpenAPI-specificatie in YAML:

openapi: 3.0.0
info:
  title: User API
  version: "1.0"
paths:
  /users:
    get:
      summary: Retrieve a list of users
      responses:
        "200":
          description: Successful response

OpenAPI-specificaties gebruiken bijvoorbeeld YAML om RESTful API’s te documenteren. Zo kunnen ze een duidelijke blauwdruk bieden voor het genereren van client-SDK’s, interactieve API-documentatie en geautomatiseerd testen. Dit gestructureerde formaat zorgt voor consistentie tussen API-implementaties.

Werken met YAML-bestanden

YAML wordt veel gebruikt voor configuratiebestanden, automatisering en gegevensserialisatie, maar omdat het op inspringing leunt, is de juiste opmaak cruciaal. Zo lees, schrijf, valideer en bewerk je YAML effectief.

YAML lezen en schrijven in Python

De Python-bibliotheek PyYAML kan YAML parsen en genereren.

Stel, je hebt het volgende YAML-configuratiebestand:

database:
  host: localhost
  port: 5432
  user: admin
  password: secret

Zo kun je met je configuratiebestand werken in Python:

import yaml

# Load YAML data
with open("config.yaml", "r") as file:
    data = yaml.safe_load(file)  # safe_load prevents arbitrary code execution

# Modify data (optional)
data["database"]["user"] = "new_user"

# Write YAML data
with open("output.yaml", "w") as file:
    yaml.dump(data, file, default_flow_style=False)

Als je geïnteresseerd bent in werken met JSON-data in Python, bekijk dan de comprehensieve Python JSON-tutorial.

YAML-bestanden valideren

Gebruik tools om de juiste structuur te waarborgen, zoals het controleren op tabs in plaats van spaties of gekke issues zoals dubbele tekens, syntaxisproblemen en trailing spaces.

Dit zijn enkele populaire YAML-validators:

• CLI-tool: yamllint (Python-gebaseerde linter)
• Online validators: YAML Lint, JSON Formatter’s YAML Validator

YAML bewerken

Je kunt YAML in elke teksteditor schrijven en bewerken, maar linting-tools en syntax highlighting verbeteren de leesbaarheid.

Een paar van mijn favoriete editors:

• VS Code (met YAML-plugins)
• PyCharm (ondersteuning ingebouwd)
• Sublime Text (met YAML-syntax highlighting)

Veelgemaakte fouten om te vermijden in YAML

Ondanks de eenvoud kun je bij YAML nog steeds makkelijk problemen en typefouten krijgen. In dit onderdeel bespreken we die fouten en geven we best practices voor het schrijven van schone en correcte bestanden. Daarom raad ik ook een linter of teksteditor aan!

Tabs en spaties door elkaar gebruiken

YAML leunt op spaties voor inspringing—meng nooit spaties en tabs. Tabs breken je YAML-script simpelweg. Dat is een bewuste keuze: verschillende systemen lezen tabs anders, en om problemen te minimaliseren, zijn spaties de voorkeursoptie.

Onjuiste inspringing

Zorg voor consistente inspringing om parsefouten te voorkomen. Omdat inspringing de enige manier is waarop YAML hiërarchie aanduidt, kan onjuiste inspringing problemen veroorzaken in je code. Je kunt een key: value-paar makkelijk op de verkeerde plek laten belanden, dus let goed op die inspringingen!

Vergeten aanhalingstekens te gebruiken bij speciale tekens

Gebruik aanhalingstekens voor strings met speciale tekens of spaties. Dingen als backslashes, komma’s, uitroeptekens enzovoort hebben aanhalingstekens nodig om als string gelezen te worden.

path: "/home/user/documents"
message: "Hello, World!"

Met de juiste validatie, gestructureerd bewerken en Python’s PyYAML kun je efficiënt met YAML-bestanden werken en veelvoorkomende valkuilen vermijden.

Conclusie

YAML is een krachtig maar eenvoudig formaat dat veel wordt gebruikt voor configuratie, gegevensserialisatie en infrastructuurautomatisering. Door de syntaxis, structuur en best practices te begrijpen, kun je in allerlei toepassingen efficiënt met YAML werken.

Als je YAML in praktijkscenario’s wilt toepassen:

• Leer hoe YAML wordt gebruikt in CI/CD-workflows met deze CI/CD for Machine Learning-cursus.
• Ontdek hoe API’s YAML gebruiken in hun specificaties in deze Introduction to APIs in Python-cursus.
• Verdiep je in containerization en infrastructuurautomatisering in dit Containerization and Virtualization-traject.