Fiche explication des fichiers yaml

Par /

1. Introduction

Dans les environnements Linux modernes, les fichiers YAML apparaissent partout. Tu les retrouves dans Docker Compose, Kubernetes, Ansible, Netplan, GitLab CI/CD, Home Assistant ou encore les fichiers de configuration cloud.

En BTS CIEL ou SIO, comprendre YAML devient rapidement indispensable. Ce format sert à stocker des paramètres de configuration de manière lisible et structurée. Beaucoup d’outils récents remplacent les anciens fichiers .conf, .ini ou XML par YAML grâce à sa simplicité.

Dans cette fiche, tu vas apprendre :

  • ce qu’est YAML ;
  • comment lire et écrire un fichier YAML ;
  • les règles de syntaxe importantes ;
  • les erreurs fréquentes ;
  • les cas d’usage sous Debian et Ubuntu ;
  • les bonnes pratiques de sécurité et de maintenance.

2. Sommaire

  1. Introduction
  2. Sommaire
  3. Comprendre YAML
  4. Structure et syntaxe
  5. Les types de données YAML
  6. Les règles d’indentation
  7. Exemples concrets sous Linux
  8. Cas pratique avec Netplan
  9. Cas pratique avec Docker Compose
  10. Validation et dépannage
  11. Fichiers importants
  12. Commandes utiles
  13. Logs et diagnostic
  14. Erreurs fréquentes
  15. Bonnes pratiques
  16. Pour aller plus loin
  17. Liens utiles
  18. Propositions de TP
  19. Conclusion

Synthèse Markdown pour ta fiche bristol

# YAML - Rappel rapide

## Structure clé / valeur
cle: valeur

## Liste
services:
  - apache
  - mariadb
  - ssh

## Dictionnaire imbriqué
reseau:
  ip: 192.168.1.10
  masque: 255.255.255.0

## Attention à l'indentation
service:
  nom: nginx
  port: 80

## Booléens
active: true

## Chaînes
nom: "Serveur Web"

## Commentaire
# Ceci est un commentaire

## Validation YAML
yamllint fichier.yaml

## Vérification Netplan
sudo netplan try

## Docker Compose
docker compose config

3. Comprendre YAML

YAML signifie :

YAML Ain't Markup Language

Contrairement au XML ou au HTML, YAML ne sert pas à afficher du contenu. Il sert à stocker des données structurées.

Le format YAML privilégie :

  • la lisibilité ;
  • la simplicité ;
  • l’organisation hiérarchique.

Tu retrouves généralement les extensions suivantes :

.yaml
.yml

Les deux fonctionnent.

4. Structure et syntaxe

YAML repose principalement sur :

  • les clés ;
  • les valeurs ;
  • l’indentation.

Exemple simple :

nom: serveur-web
ip: 192.168.1.10
port: 80

Ici :

  • nom est une clé ;
  • serveur-web est une valeur.

4.1 Structure imbriquée

serveur:
  nom: web01
  ip: 192.168.1.20

Le bloc nom et ip appartient à serveur.

4.2 Les listes

services:
  - apache2
  - mariadb
  - ssh

Le tiret - représente un élément de liste.

5. Les types de données YAML

5.1 Chaînes de caractères

nom: "Debian Server"

Les guillemets restent facultatifs dans beaucoup de cas :

nom: Debian

5.2 Nombres

port: 443

5.3 Booléens

active: true
debug: false

5.4 Listes

dns:
  - 1.1.1.1
  - 8.8.8.8

5.5 Dictionnaires

utilisateur:
  nom: admin
  shell: /bin/bash

6. Les règles d’indentation

L’indentation représente le point le plus important dans YAML.

YAML n’utilise pas les accolades {} comme JSON.
Il utilise les espaces.

6.1 Toujours utiliser des espaces

Utilise généralement :

2 espaces

ou :

4 espaces

Évite les tabulations.

Mauvais exemple

serveur:
nom: web01
ip: 192.168.1.10

Bon exemple

serveur:
  nom: web01
  ip: 192.168.1.10

7. Exemples concrets sous Linux

7.1 Exemple avec Ansible

Fichier :

/etc/ansible/playbook.yml
---
- hosts: webservers
  become: true

  tasks:
    - name: Installer nginx
      apt:
        name: nginx
        state: present

Explications

  • hosts définit les machines ciblées ;
  • become: true active sudo ;
  • apt utilise le module de gestion des paquets Debian.

7.2 Exemple avec Kubernetes

apiVersion: v1
kind: Pod

metadata:
  name: nginx-pod

spec:
  containers:
    - name: nginx
      image: nginx:latest
      ports:
        - containerPort: 80

8. Cas pratique avec Netplan

Ubuntu utilise Netplan pour gérer la configuration réseau.

8.1 Fichier concerné

/etc/netplan/00-installer-config.yaml

8.2 Configuration complète

network:
  version: 2
  renderer: networkd

  ethernets:
    ens33:
      dhcp4: false

      addresses:
        - 192.168.1.50/24

      routes:
        - to: default
          via: 192.168.1.1

      nameservers:
        addresses:
          - 1.1.1.1
          - 8.8.8.8

Explications détaillées

version: 2

Définit la version de syntaxe Netplan.

renderer: networkd

Utilise systemd-networkd.

Tu pourrais aussi utiliser :

renderer: NetworkManager

sur une machine de bureau Ubuntu.

dhcp4: false

Désactive DHCP IPv4.

addresses

Configure l’adresse IP statique.

routes

Définit la passerelle par défaut.

nameservers

Configure les serveurs DNS.

9. Cas pratique avec Docker Compose

Fichier concerné

docker-compose.yml

Configuration complète

services:
  wordpress:
    image: wordpress:latest

    ports:
      - "8080:80"

    environment:
      WORDPRESS_DB_HOST: mariadb
      WORDPRESS_DB_USER: wpuser
      WORDPRESS_DB_PASSWORD: motdepasse
      WORDPRESS_DB_NAME: wordpress

    volumes:
      - wordpress_data:/var/www/html

    depends_on:
      - mariadb

  mariadb:
    image: mariadb:latest

    environment:
      MYSQL_ROOT_PASSWORD: rootpass
      MYSQL_DATABASE: wordpress
      MYSQL_USER: wpuser
      MYSQL_PASSWORD: motdepasse

    volumes:
      - mariadb_data:/var/lib/mysql

volumes:
  wordpress_data:
  mariadb_data:

10. Validation et dépannage

10.1 Installer yamllint

Sous Debian/Ubuntu :

sudo apt update
sudo apt install yamllint

Vérifier un fichier YAML

yamllint fichier.yaml

Cette commande détecte :

  • les erreurs d’indentation ;
  • les espaces incorrects ;
  • les fautes de syntaxe.

10.2 Validation Docker Compose

docker compose config

Cette commande :

  • vérifie la syntaxe ;
  • fusionne les configurations ;
  • affiche la configuration finale.

10.3 Validation Netplan

sudo netplan try

try applique temporairement la configuration.

Si la configuration casse le réseau, Ubuntu revient automatiquement à l’ancienne configuration.

Ensuite :

sudo netplan apply

applique définitivement les changements.

11. Fichiers importants

/etc/netplan/*.yaml
/etc/cloud/cloud.cfg
/etc/ansible/*.yml
docker-compose.yml
/etc/kubernetes/
/var/lib/cloud/
/etc/gitlab-runner/config.toml

12. Commandes utiles

Installer yamllint

sudo apt install yamllint

Vérifier un fichier YAML

yamllint fichier.yaml

Vérifier une configuration Docker Compose

docker compose config

Vérifier Netplan

sudo netplan generate

Génère la configuration sans l’appliquer.

Appliquer Netplan

sudo netplan apply

Tester Netplan

sudo netplan try

13. Logs et diagnostic

13.1 Logs Netplan

journalctl -u systemd-networkd

Tu peux aussi utiliser :

journalctl -xe

pour afficher les dernières erreurs système.

13.2 Logs Docker

docker compose logs

Pour suivre les logs en temps réel :

docker compose logs -f

Option -f :

follow

équivalent de tail -f.

13.3 Débogage YAML

Beaucoup d’erreurs viennent :

  • des espaces ;
  • des tabulations ;
  • d’un mauvais alignement ;
  • d’un oubli de :.

14. Erreurs fréquentes

Utiliser des tabulations

YAML supporte mal les tabulations.

Privilégie les espaces.

Mauvaise indentation

services:
- nginx

devrait être :

services:
  - nginx

Oublier les deux-points

Incorrect :

nom serveur

Correct :

nom: serveur

15. Bonnes pratiques

  • Utilise toujours des espaces ;
  • Garde une indentation cohérente ;
  • Vérifie les fichiers avec yamllint ;
  • Ajoute des commentaires ;
  • Évite les fichiers gigantesques ;
  • Sépare les rôles et services ;
  • Versionne les fichiers avec Git ;
  • Sauvegarde les configurations avant modification.

16. Pour aller plus loin

Tu peux ensuite apprendre :

  • Docker Compose ;
  • Kubernetes ;
  • Ansible ;
  • GitLab CI/CD ;
  • Home Assistant ;
  • Terraform.

Tous utilisent YAML intensivement.

17. Liens vers les sites officiels, MOOC et documentations

Documentation officielle YAML

https://yaml.org/spec

Permet de consulter la spécification officielle du langage YAML.

Documentation Netplan Ubuntu

https://netplan.readthedocs.io/en/stable

Documentation officielle complète sur la configuration réseau Ubuntu.

Documentation Docker Compose

https://docs.docker.com/compose

Référence officielle pour les fichiers docker-compose.yml.

Documentation Kubernetes YAML

https://kubernetes.io/docs/concepts/overview/working-with-objects

Explique les objets Kubernetes et leur structure YAML.

OpenClassrooms — Découvrez Docker

https://openclassrooms.com/fr/courses/6597086-initiez-vous-a-docker

Très bon cours pour comprendre les fichiers Compose.

OpenClassrooms — Administrez Linux

https://openclassrooms.com/fr/courses/7170491-administrez-linux

Excellent support pour les bases système Linux.

18. Propositions de TP pour s’exercer

TP 1 — Créer un fichier YAML simple

Objectifs :

  • créer une structure ;
  • ajouter des listes ;
  • corriger les erreurs d’indentation.

TP 2 — Configurer une IP statique avec Netplan

Objectifs :

  • modifier /etc/netplan/*.yaml ;
  • appliquer la configuration ;
  • tester la connectivité réseau.

TP 3 — Déployer WordPress avec Docker Compose

Objectifs :

  • créer un docker-compose.yml ;
  • démarrer les conteneurs ;
  • vérifier les logs.

TP 4 — Valider plusieurs fichiers YAML

Objectifs :

  • installer yamllint ;
  • détecter des erreurs ;
  • corriger les problèmes de syntaxe.

19. Conclusion

YAML constitue aujourd’hui un format incontournable dans l’administration système, le DevOps et le cloud. Sa simplicité apparente cache une exigence importante sur la rigueur d’écriture, notamment concernant l’indentation.

En maîtrisant correctement YAML, tu pourras comprendre beaucoup plus facilement les outils modernes comme Docker, Kubernetes, Ansible ou Netplan. Prends l’habitude de valider systématiquement tes fichiers avant leur déploiement et conserve une structure propre et lisible pour faciliter la maintenance des configurations

Publications similaires

Retour en haut