Trabajo con YAML en Go (Golang): bibliotecas go-yaml y yaml.v3

Trabajo con YAML en Go (Golang): Guía completa

YAML (YAML Ain't Markup Language) es un formato de serialización de datos legible por humanos, ampliamente utilizado para archivos de configuración, descripción de infraestructura (por ejemplo, Kubernetes, Docker Compose) e intercambio de datos. En el ecosistema de Go (Golang), el trabajo con YAML se implementa a través de potentes bibliotecas de terceros, principalmente a través de go-yaml (conocida como gopkg.in/yaml.v3). En este artículo, analizaremos en detalle cómo analizar, crear y procesar documentos YAML en Go.

¿Por qué es importante YAML para un desarrollador de Go?

Go es un lenguaje para crear aplicaciones de servidor de alto rendimiento, herramientas DevOps y microservicios. YAML se ha convertido en el estándar de facto para:

• Configuraciones de aplicaciones (por ejemplo, config.yaml);
• Manifiestos de Kubernetes (deployment.yaml);
• Pipelines de CI/CD (GitLab CI, GitHub Actions);
• Descripción de API y esquemas de datos.

Sin la capacidad de trabajar con YAML en Go, el desarrollo moderno en este lenguaje es inimaginable.

Bibliotecas principales para trabajar con YAML en Go

Hoy en día, existen dos versiones principales de la biblioteca:

• gopkg.in/yaml.v2 — versión estable antigua, todavía popular;
• gopkg.in/yaml.v3 — versión actual con soporte para etiquetas, canales y manejo mejorado de errores (recomendada para nuevos proyectos).

Ambas bibliotecas proporcionan las funciones Marshal (estructura → YAML) y Unmarshal (YAML → estructura).

Instalación de la biblioteca

Para comenzar, agregue el paquete al proyecto:

go get gopkg.in/yaml.v3

Impórtelo en el código:

import "gopkg.in/yaml.v3"

Ejemplo 1: Análisis de YAML en una estructura (Unmarshal)

Creemos un archivo de configuración 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"

Ahora escribamos el código Go para leer este archivo:

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)}

Salida:

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

Ejemplo 2: Serialización de una estructura a YAML (Marshal)

Ahora creemos una estructura y la convertimos a 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