Arbeiten mit YAML in Go (Golang): Bibliotheken go-yaml und yaml.v3

Arbeiten mit YAML in Go (Golang): Vollständige Anleitung

YAML (YAML Ain't Markup Language) ist ein menschenlesbares Daten serialisierungsformat, das häufig für Konfigurationsdateien, Infrastrukturbeschreibungen (z. B. Kubernetes, Docker Compose) und Datenaustausch verwendet wird. Im Go (Golang)-Ökosystem wird die Arbeit mit YAML über leistungsstarke Drittanbieter-Bibliotheken realisiert, hauptsächlich über go-yaml (bekannt als gopkg.in/yaml.v3). In diesem Artikel werden wir im Detail besprechen, wie man YAML-Dokumente in Go parst, erstellt und verarbeitet.

Warum ist YAML für Go-Entwickler wichtig?

Go ist eine Sprache für die Entwicklung leistungsstarker Serveranwendungen, DevOps-Tools und Microservices. YAML hat sich zum De-facto-Standard entwickelt für:

• Anwendungskonfigurationen (z. B. config.yaml);
• Kubernetes-Manifeste (deployment.yaml);
• CI/CD-Pipelines (GitLab CI, GitHub Actions);
• API-Beschreibungen und Datenschemata.

Ohne die Fähigkeit, mit YAML in Go zu arbeiten, ist moderne Entwicklung in dieser Sprache nicht vorstellbar.

Wichtige Bibliotheken für die Arbeit mit YAML in Go

Derzeit gibt es zwei Hauptversionen der Bibliothek:

• gopkg.in/yaml.v2 — ältere stabile Version, immer noch beliebt;
• gopkg.in/yaml.v3 — aktuelle Version mit Unterstützung für Tags, Kanäle und verbesserter Fehlerbehandlung (für neue Projekte empfohlen).

Beide Bibliotheken bieten die Funktionen Marshal (Struktur → YAML) und Unmarshal (YAML → Struktur).

Installation der Bibliothek

Fügen Sie das Paket zu Ihrem Projekt hinzu:

go get gopkg.in/yaml.v3

Importieren Sie es in Ihren Code:

import "gopkg.in/yaml.v3"

Beispiel 1: YAML in eine Struktur parsen (Unmarshal)

Erstellen wir eine Konfigurationsdatei 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"

Jetzt schreiben wir Go-Code, um diese Datei zu lesen:

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

Ausgabe:

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

Beispiel 2: Struktur in YAML serialisieren (Marshal)

Jetzt erstellen wir eine Struktur und wandeln sie in YAML um:

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