Trabajo con YAML en Go (Golang) — bibliotecas gopkg.in/yaml.v3 y encoding/json

Trabajo con YAML en Go (Golang) — biblioteca gopkg.in/yaml.v3

YAML (YAML Ain't Markup Language) es un formato popular de serialización de datos, utilizado a menudo para archivos de configuración, descripción de API (OpenAPI/Swagger), pipelines de CI/CD (GitLab CI, GitHub Actions) y Docker Compose. En el ecosistema de Go (Golang) no existe una biblioteca estándar para trabajar con YAML, por lo que los desarrolladores utilizan la potente y estable biblioteca de terceros gopkg.in/yaml.v3. En este artículo, analizaremos en detalle cómo leer, escribir y procesar YAML en Go.

Instalación de la biblioteca

Para empezar, agregue el paquete a su proyecto:

go get gopkg.in/yaml.v3

Después, impórtelo en su código:

import "gopkg.in/yaml.v3"

Estructuras principales para trabajar con YAML

La biblioteca yaml.v3 soporta:

• Marshaling (Marshal) — conversión de estructuras Go a una cadena YAML.
• Unmarshaling (Unmarshal) — parseo de una cadena YAML a una estructura Go.
• Parseo por flujo (Decoder/Encoder) para trabajar con archivos.
• Etiquetas yaml:"fieldname" para configurar los nombres de los campos.

Ejemplo 1: Lectura de YAML desde una cadena

El caso más simple es analizar una cadena YAML en una estructura Go:

package main

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

type Config struct {    Server struct {        Port int    `yaml:"port"`        Host string `yaml:"host"`    } `yaml:"server"`    Database struct {        User string `yaml:"user"`        Pass string `yaml:"pass"`    } `yaml:"database"`}

func main() {    yamlData := `server:  port: 8080  host: "localhost"database:  user: "admin"  pass: "secret"`    var cfg Config    err := yaml.Unmarshal([]byte(yamlData), &cfg)    if err != nil {        panic(err)    }    fmt.Printf("Servidor: %s:%d", cfg.Server.Host, cfg.Server.Port)    fmt.Printf("Base de datos: %s", cfg.Database.User)}

Ejemplo 2: Escritura de YAML en un archivo

Para escribir datos en un archivo YAML, use yaml.Marshal y escritura en el sistema de archivos:

package main

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

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

func main() {    config := AppConfig{        Name:    "MyApp",        Version: "1.0.0",        Debug:   true,    }

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

    err = os.WriteFile("config.yaml", data, 0644)    if err != nil {        panic(err)    }    println("Archivo config.yaml creado")}

Ejemplo 3: Trabajo con estructuras anidadas y complejas

YAML soporta listas, estructuras map y anidamiento profundo. Aquí hay un ejemplo de parseo de una lista de servidores:

package main

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

type Service struct {    Name    string   `yaml:"name"`    Ports   []int    `yaml:"ports"`    Enabled bool     `yaml:"enabled"`}

type Deployment struct {    Version  string    `yaml:"version"`    Services []Service `yaml:"services"`}

func main() {    input := `version: "2.1"services:  - name: web    ports: [80, 443]    enabled: true  - name: api    ports: [3000]    enabled: false`    var dep Deployment    if err := yaml.Unmarshal([]byte(input), &dep); err != nil {        panic(err)    }

    for _, s := range dep.Services {        fmt.Printf("Servicio %s: puertos %v, activo: %t", s.Name, s.Ports, s.Enabled)    }}

Lectura y escritura por flujo (Decoder/Encoder)

Para trabajar con archivos grandes o flujos de datos, use yaml.Decoder y yaml.Encoder:

package main

import (    "