Travailler avec YAML en Go (Golang) : bibliothèques go-yaml et yaml.v3

Travailler avec YAML en Go (Golang) : Guide complet

YAML (YAML Ain't Markup Language) est un format de sérialisation de données lisible par l'homme, largement utilisé pour les fichiers de configuration, la description d'infrastructure (par exemple, Kubernetes, Docker Compose) et l'échange de données. Dans l'écosystème Go (Golang), le travail avec YAML est implémenté via de puissantes bibliothèques tierces, principalement via go-yaml (connue sous le nom de gopkg.in/yaml.v3). Dans cet article, nous allons détailler comment analyser, créer et traiter des documents YAML en Go.

Pourquoi YAML est-il important pour un développeur Go ?

Go est un langage pour créer des applications serveur hautes performances, des outils DevOps et des microservices. YAML est devenu le standard de facto pour :

• Les configurations d'applications (par exemple, config.yaml);
• Les manifestes Kubernetes (deployment.yaml);
• Les pipelines CI/CD (GitLab CI, GitHub Actions);
• La description d'API et de schémas de données.

Sans savoir travailler avec YAML en Go, le développement moderne dans ce langage est inimaginable.

Bibliothèques principales pour travailler avec YAML en Go

Aujourd'hui, il existe deux versions principales de la bibliothèque :

• gopkg.in/yaml.v2 — ancienne version stable, toujours populaire ;
• gopkg.in/yaml.v3 — version actuelle avec prise en charge des tags, des canaux et une gestion améliorée des erreurs (recommandée pour les nouveaux projets).

Les deux bibliothèques fournissent les fonctions Marshal (structure → YAML) et Unmarshal (YAML → structure).

Installation de la bibliothèque

Pour commencer, ajoutez le package au projet :

go get gopkg.in/yaml.v3

Importez-le dans le code :

import "gopkg.in/yaml.v3"

Exemple 1 : Analyse YAML en structure (Unmarshal)

Créons un fichier de configuration config.yaml :

server:  host: "localhost"  port: 8080database:  driver: "postgres"  dsn: "host=localhost user=app password=secret dbname=mydb"logging:  level: "info"  file: "/var/log/app.log"

Écrivons maintenant le code Go pour lire ce fichier :

package main

import (    "fmt"    "os"    "gopkg.in/yaml.v3")

type Config struct {    Server   ServerConfig   `yaml:"server"`    Database DatabaseConfig `yaml:"database"`    Logging  LoggingConfig  `yaml:"logging"`}

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

type DatabaseConfig struct {    Driver string `yaml:"driver"`    DSN    string `yaml:"dsn"`}

type LoggingConfig struct {    Level string `yaml:"level"`    File  string `yaml:"file"`}

func main() {    data, err := os.ReadFile("config.yaml")    if err != nil {        panic(err)    }

    var cfg Config    err = yaml.Unmarshal(data, &cfg)    if err != nil {        panic(err)    }

    fmt.Printf("Server: %s:%d", cfg.Server.Host, cfg.Server.Port)    fmt.Printf("Database driver: %s", cfg.Database.Driver)    fmt.Printf("Log level: %s", cfg.Logging.Level)}

Sortie :

Server: localhost:8080Database driver: postgresLog level: info

Exemple 2 : Sérialisation d'une structure en YAML (Marshal)

Créons maintenant une structure et convertissons-la en YAML :

package main

import (    "fmt"    "gopkg.in/yaml.v3")

type AppConfig struct {    Name    string   `yaml:"name"`    Version string   `yaml:"version"`    Debug   bool     `yaml:"debug"`    Tags    []string `yaml:"tags"`}

func main() {    cfg := AppConfig{        Name:    "MyApp",        Version: "1.0.0",        Debug:   false,        Tags:    []string{"production", "stable"},    }

    out, err := yaml.Marshal(&cfg)    if err != nil {        panic(err)    }

    fmt.P