Trabalhando com YAML em Go (Golang): bibliotecas go-yaml e yaml.v3

Trabalhando com YAML em Go (Golang): Guia Completo

YAML (YAML Ain't Markup Language) é um formato de serialização de dados legível por humanos, amplamente utilizado para arquivos de configuração, descrição de infraestrutura (por exemplo, Kubernetes, Docker Compose) e troca de dados. No ecossistema Go (Golang), o trabalho com YAML é implementado através de poderosas bibliotecas de terceiros, principalmente através do go-yaml (conhecido como gopkg.in/yaml.v3). Neste artigo, vamos detalhar como fazer parsing, criar e processar documentos YAML em Go.

Por que o YAML é importante para o desenvolvedor Go?

Go é uma linguagem para criar aplicações servidoras de alto desempenho, ferramentas DevOps e microsserviços. O YAML tornou-se o padrão de facto para:

• Configurações de aplicações (por exemplo, config.yaml);
• Manifestos do Kubernetes (deployment.yaml);
• Pipelines de CI/CD (GitLab CI, GitHub Actions);
• Descrição de APIs e esquemas de dados.

Sem a habilidade de trabalhar com YAML em Go, é impossível imaginar o desenvolvimento moderno nesta linguagem.

Principais bibliotecas para trabalhar com YAML em Go

Atualmente, existem duas versões principais da biblioteca:

• gopkg.in/yaml.v2 — versão estável antiga, ainda popular;
• gopkg.in/yaml.v3 — versão atual com suporte a tags, canais e tratamento de erros aprimorado (recomendada para novos projetos).

Ambas as bibliotecas fornecem as funções Marshal (estrutura → YAML) e Unmarshal (YAML → estrutura).

Instalação da biblioteca

Para começar, adicione o pacote ao projeto:

go get gopkg.in/yaml.v3

Importe-o no código:

import "gopkg.in/yaml.v3"

Exemplo 1: Parsing de YAML para estrutura (Unmarshal)

Vamos criar um arquivo de configuração 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"

Agora vamos escrever o código Go para ler este arquivo:

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

Saída:

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

Exemplo 2: Serialização de estrutura para YAML (Marshal)

Agora vamos criar uma estrutura e convertê-la para 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