What's the idiomatic way of parsing dynamic YAML in Go?

I have some code for handling a YAML config file that's getting a little out-of-control w/ type assertions and I feel like there must be a better way to do this.

Here's the relevant snippet from my config file:

plugins:
  taxii20:
    default: default
    api_roots:
      default:
        auth:
          - ldap
          - mutualtls
        collections:
          all:
            selector: g.V().Save("<type>").Save("<created>").All()
            selector_query_lang: gizmo

And here's my parsing code:

func parseTaxiiConfig() {
	plg.ConfigMutex.Lock()
	taxiiConfig := plg.ConfigData.Plugins["taxii20"].(map[interface{}]interface{})
	ConfigData = &Config{}
	if taxiiConfig["default"] != nil {
		ConfigData.DefaultRoot = taxiiConfig["default"].(string)
	}
	if taxiiConfig["api_roots"] != nil {
		ConfigData.APIRoots = make([]model.APIRoot, 0)
		iroots := taxiiConfig["api_roots"].(map[interface{}]interface{})
		for iname, iroot := range iroots {
			root := model.APIRoot{Name: iname.(string)}
			authMethods := iroot.(map[interface{}]interface{})["auth"].([]interface{})
			root.AuthMethods = make([]string, 0)
			for _, method := range authMethods {
				root.AuthMethods = append(root.AuthMethods, method.(string))
			}
			collections := iroot.(map[interface{}]interface{})["collections"].(map[interface{}]interface{})
			root.Collections = make([]model.Collection, 0)
			for icolName, icollection := range collections {
				collection := model.Collection{Name: icolName.(string)}
				collection.Selector = icollection.(map[interface{}]interface{})["selector"].(string)
				collection.SelectorQueryLang = icollection.(map[interface{}]interface{})["selector_query_lang"].(string)
				root.Collections = append(root.Collections, collection)
			}
			ConfigData.APIRoots = append(ConfigData.APIRoots, root)
		}
	}
	plg.ConfigMutex.Unlock()

    // debug
	fmt.Println(ConfigData)
}

The code works as intended, but there's just so many type assertions here and I can't shake the feeling that I'm missing a better way.

One possible critical item of note, as the config implies, this is configuration for a Caddy-style plugin system, so the main config parser cannot know ahead of time what the shape of the plugin config will look like. It has to delegate processing of the plugin's portion of the config file to the plugin itself.

Here's what I came up with instead. Much more readable.

// Config represents TAXII 2.0 plugin structure
type Config struct {
DefaultRoot string
APIRoots    []model.APIRoot
}
// Intermediate config for mapstructure
type configRaw struct {
DefaultRoot string                `mapstructure:"default"`
APIRoots    map[string]apiRootRaw `mapstructure:"api_roots"`
}
type apiRootRaw struct {
AuthMethods []string                 `mapstructure:"auth"`
Collections map[string]collectionRaw `mapstructure:"collections"`
}
type collectionRaw struct {
Selector          string `mapstructure:"selector"`
SelectorQueryLang string `mapstructure:"selector_query_lang"`
}
func parseTaxiiConfig() error {
plg.ConfigMutex.Lock()
defer plg.ConfigMutex.Unlock()
taxiiConfig := plg.ConfigData.Plugins["taxii20"].(map[interface{}]interface{})
fmt.Println(taxiiConfig)
ConfigData = &Config{}
raw := &configRaw{}
err := mapstructure.Decode(taxiiConfig, raw)
if err != nil {
return err
}
ConfigData.DefaultRoot = raw.DefaultRoot
ConfigData.APIRoots = make([]model.APIRoot, 0)
for name, root := range raw.APIRoots {
apiRoot := model.APIRoot{Name: name}
apiRoot.AuthMethods = root.AuthMethods
apiRoot.Collections = make([]model.Collection, 0)
for colName, col := range root.Collections {
collection := model.Collection{Name: colName}
collection.Selector = col.Selector
collection.SelectorQueryLang = col.SelectorQueryLang
apiRoot.Collections = append(apiRoot.Collections, collection)
}
ConfigData.APIRoots = append(ConfigData.APIRoots, apiRoot)
}
return nil
}