golang modify yaml data

For applications developed using Golang, among the common data storage methods, YAML format data files are also a commonly used method. Because files in the YAML format are highly readable and have clear structures, they are widely used in a variety of scenarios. For example, Kubernetes configuration files are stored in the YAML format. When you need to modify YAML format data, how to use Golang to achieve it? The following will take modifying the YAML configuration file of Kubernetes as an example to introduce how to use Golang to implement it.

Import necessary libraries

You need to use the "gopkg.in/yaml.v2" library in the code to read and modify data in YAML format. Since Go modules, Golang's dependency management tool, comes with its own dependency management function, we only need to reference this library.

import (
    "fmt"
    "io/ioutil"
    "gopkg.in/yaml.v2"
)

Read YAML data

Before modifying the YAML data, you first need to read the YAML data. Here you can use the ReadFile function in the ioutil library to read the file. Since the Kubernetes configuration file is a document that can contain multiple objects, all objects in the file need to be separated by "---".

func readYamlFile(filepath string) ([]map[interface{}]interface{}, error) {
    yamlFile, err := ioutil.ReadFile(filepath)
    if err != nil {
        return nil, err
    }
    var data []map[interface{}]interface{}
    for _, item := range bytes.Split(yamlFile, []byte("
---
")) {
        var obj map[interface{}]interface{}
        if err := yaml.Unmarshal(item, &obj); err != nil {
            return nil, err
        }
        data = append(data, obj)
    }
    return data, nil
}

The return value of this function is a []map[interface{}]interface{} type of data. Each element represents a YAML object. In the Kubernetes configuration file, each object usually represents a Deployment, Service or Pod, etc.

Modify YAML data

Suppose we need to change the Replicas of a Deployment from the original 3 to 4, then we need to find the Deployment object and then modify the value of the Replicas field. Since each field of data in YAML format is a map, modifying the value of a field is very simple. You only need to find the map where the field is located, and then modify the value of the map. Here, when traversing each YAML object, we check whether the current one is the Deployment we need to modify. If so, find the Replicas field and modify it.

func modifyYamlData(data []map[interface{}]interface{}, objectName string, fieldName string, fieldValue interface{}) error {
    for _, obj := range data {
        if obj["kind"] == "Deployment" && obj["metadata"].(map[interface{}]interface{})["name"] == objectName {
            spec := obj["spec"].(map[interface{}]interface{})
            replicas := spec["replicas"].(int)
            if replicas != fieldValue {
                spec["replicas"] = fieldValue
                yamlData, err := yaml.Marshal(data)
                if err != nil {
                    return err
                }
                return ioutil.WriteFile("k8s.yaml", yamlData, 0644)
            }
            break
        }
    }
    return nil
}

The parameters of this function are the read YAML data, the object name, attribute name and attribute value that need to be modified. If the object that needs to be modified is found and modified, it can be written directly to the file.

Complete code

The following is a complete program for modifying the Replicas attribute of the Deployment in the Kubernetes configuration file. You can extend and modify other attributes on this basis.

package main

import (
    "bytes"
    "fmt"
    "io/ioutil"
  
    "gopkg.in/yaml.v2"
)

func readYamlFile(filepath string) ([]map[interface{}]interface{}, error) {
    yamlFile, err := ioutil.ReadFile(filepath)
    if err != nil {
        return nil, err
    }
    var data []map[interface{}]interface{}
    for _, item := range bytes.Split(yamlFile, []byte("
---
")) {
        var obj map[interface{}]interface{}
        if err := yaml.Unmarshal(item, &obj); err != nil {
            return nil, err
        }
        data = append(data, obj)
    }
    return data, nil
}

func modifyYamlData(data []map[interface{}]interface{}, objectName string, fieldName string, fieldValue interface{}) error {
    for _, obj := range data {
        if obj["kind"] == "Deployment" && obj["metadata"].(map[interface{}]interface{})["name"] == objectName {
            spec := obj["spec"].(map[interface{}]interface{})
            replicas := spec["replicas"].(int)
            if replicas != fieldValue {
                spec["replicas"] = fieldValue
                yamlData, err := yaml.Marshal(data)
                if err != nil {
                    return err
                }
                return ioutil.WriteFile("k8s.yaml", yamlData, 0644)
            }
            break
        }
    }
    return nil
}

func main() {
    data, err := readYamlFile("k8s.yaml")
    if err != nil {
        fmt.Println(err)
        return
    }
    if err := modifyYamlData(data, "nginx", "replicas", 4); err != nil {
        fmt.Println(err)
        return
    }
}

Summary

Through the above code, we can see that it is relatively easy to use Golang to modify data in YAML format. Compared with JSON, YAML is easier to read and edit, and Golang also provides a large number of convenient tools to implement reading and writing operations on complex data types. Therefore, for application scenarios that need to process complex data, using Golang to process YAML data is very suitable.

The above is the detailed content of golang modify yaml data. For more information, please follow other related articles on the PHP Chinese website!