How to read a YAML file

I have an issue with reading a YAML file. I think it's something in the file structure but I can't figure out what.

YAML file:

conf:
  hits:5
  time:5000000

code:

type conf struct {
	hits int64 `yaml:"hits"`
	time int64 `yaml:"time"`
}


func (c *conf) getConf() *conf {

	yamlFile, err := ioutil.ReadFile("conf.yaml")
	if err != nil {
		log.Printf("yamlFile.Get err   #%v ", err)
	}
	err = yaml.Unmarshal(yamlFile, c)
	if err != nil {
		log.Fatalf("Unmarshal: %v", err)
	}

	return c
}

your yaml file must be

hits: 5
time: 5000000

your code should look like this:

package main

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

type conf struct {
	Hits int64 `yaml:"hits"`
	Time int64 `yaml:"time"`
}

func (c *conf) getConf() *conf {

	yamlFile, err := ioutil.ReadFile("conf.yaml")
	if err != nil {
		log.Printf("yamlFile.Get err   #%v ", err)
	}
	err = yaml.Unmarshal(yamlFile, c)
	if err != nil {
		log.Fatalf("Unmarshal: %v", err)
	}

	return c
}

func main() {
	var c conf
	c.getConf()

	fmt.Println(c)
}

the main error was capital letter for your struct.

Using an upgraded version 3 of yaml package.

An example conf.yaml file:

conf:
  hits: 5
  time: 5000000
  camelCase: sometext

The main.go file:

package main

import (
	"fmt"
	"io/ioutil"
	"log"

	"gopkg.in/yaml.v3"
)

type myData struct {
	Conf struct {
		Hits      int64
		Time      int64
		CamelCase string `yaml:"camelCase"`
	}
}

func readConf(filename string) (*myData, error) {
	buf, err := ioutil.ReadFile(filename)
	if err != nil {
		return nil, err
	}

	c := &myData{}
	err = yaml.Unmarshal(buf, c)
	if err != nil {
		return nil, fmt.Errorf("in file %q: %v", filename, err)
	}

	return c, nil
}

func main() {
	c, err := readConf("conf.yaml")
	if err != nil {
		log.Fatal(err)
	}

	fmt.Printf("%v", c)
}

Running instructions (in case it's the first time you step out of stdlib):

go mod init example.com/whatever
go get gopkg.in/yaml.v3
cat go.sum
go run .

The tags (like yaml:"field") are optional for all-lowercase yaml key identifiers. For shows I've included a random camelCase identifier which does require such a tag.

(Confusingly, this lowercasing behavior of "yaml" is not seen in the standard "json" package. If your structure is used with both JSON and YAML encodings it is best to specify both tags on literally every field. Verbose, but reduces mistakes.)

package main

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

type someConf struct {
	AccessKeyID     string `yaml:"access_key_id"`
   //...
}

func getConf(file string, cnf interface{}) error {
   yamlFile, err := ioutil.ReadFile(file)
   if err == nil {
	  err = yaml.Unmarshal(yamlFile, cnf)
   }
   return err
}

func main() {
	cfg := &awsConf{}
	if err := getConf("conf.yml", cfg); err != nil {
		log.Panicln(err)
	}
 }

shortest getConf ever