How to Parse a YAML File with Nested Key-Value Pairs in Go?

Parsing a YAML File in Go

Parsing YAML files in Go involves utilizing the YAML library available through gopkg.in/yaml.v2. The provided code is designed to parse a YAML file with nested key-value pairs, like the following:

firewall_network_rules:
  rule1:
    src:       blablabla-host
    dst:       blabla-hostname

However, issues arise when attempting to parse key-value pairs without accompanying values. The implemented struct does not define these values, leading to an error during parsing.

To address this issue, consider incorporating a real-world YAML example, such as a service.yaml from Google Cloud or Kubernetes:

apiVersion: v1
kind: Service
metadata:
  name: myName
  namespace: default
  labels:
    router.deis.io/routable: "true"
  annotations:
    router.deis.io/domains: ""
spec:
  type: NodePort
  selector:
    app: myName
  ports:
    - name: http
      port: 80
      targetPort: 80
    - name: https
      port: 443
      targetPort: 443

This example demonstrates nested key-value relationships and provides a practical use case. The corresponding Go struct would resemble:

type Service struct {
    APIVersion string `yaml:"apiVersion"`
    Kind       string `yaml:"kind"`
    Metadata   struct {
        Name      string `yaml:"name"`
        Namespace string `yaml:"namespace"`
        Labels    struct {
            RouterDeisIoRoutable string `yaml:"router.deis.io/routable"`
        } `yaml:"labels"`
        Annotations struct {
            RouterDeisIoDomains string `yaml:"router.deis.io/domains"`
        } `yaml:"annotations"`
    }
    Spec struct {
        Type     string `yaml:"type"`
        Selector struct {
            App string `yaml:"app"`
        }
        Ports []struct {
            Name       string `yaml:"name"`
            Port       int    `yaml:"port"`
            TargetPort int    `yaml:"targetPort"`
            NodePort   int    `yaml:"nodePort,omitempty"`
        } `yaml:"ports"`
    }
}

To simplify the process, services like yaml-to-go and json-to-go provide convenient tools for converting YAML to Go structs, making the parsing task more manageable.

Finally, to unmarshal the YAML file into your struct, you can use the following code:

var service Service

err := yaml.Unmarshal(yourFile, &service)
if err != nil {
    panic(err)
}

This approach enables access to the parsed data through the service struct, allowing you to interact with the YAML file's information in your Go application.

The above is the detailed content of How to Parse a YAML File with Nested Key-Value Pairs in Go?. For more information, please follow other related articles on the PHP Chinese website!