I am trying to unmarshall the following yaml into the below structs, how do I convert the List field into a map field and access it using struct?

The YAML file:

namespaces:
  - namespace: default
    aliasname: k8s
    components:
      - component: comp1
        replicas: 1
        port: 8080
      - component: comp2
        replicas: 1
        port: 9999
  - namespace: ns2
    components:
      - component: comp1
        replicas: 1

From the YAML file above, I want to create structs like the following:

type Namespaces struct {
	NamespaceName    string       `yaml:"namespace"`
	Aliasname     string       `yaml:"aliasname,omitempty"`
	ListOfComponents []Components `yaml:"components"`
    ComponentMap     map[string]Components

}

type Components struct {
	ComponentName string `yaml:"component"`
	NumReplicas   int    `yaml:"replicas"`
	Port          int    `yaml:"port"`
}

type Config struct {
	ListOfNamespaces []Namespaces `yaml:"namespaces"`
	NamespaceMap map[string]Namespaces
}

The fields Namespacemap and Componentmap should be able to be retrieved when accessing the config and namespace object respectively. I created a method to convert the list of the namespaces and components into maps, but when I call config.Namespacemap or Namespace.ComponentMap, it returns an empty map.

Basically I would like to know: How do we add extra fields to type structs? I would like to access new variables like a map from the config struct.

Update:
Thanks blami for guiding me, but when I try to write the same for Components, it doesn't give me the whole namespacemap with the componentmap included:

type Components struct {
	ComponentName string `yaml:"component"`
	NumReplicas   int    `yaml:"replicas"`
	Port          int    `yaml:"port"`

}

type Namespaces struct {
	NamespaceName string                `yaml:"namespace"`
	Aliasname  string                `yaml:"aliasname"`
	ComponentMap  map[string]Components `yaml:"components"`
}

func (n *Namespaces) UnmarshalYAML(unmarshal func(interface{}) error) error {

	type origNamespace struct {
		ListOfComponents []Components `yaml:"components"`
	}

	var on origNamespace
	err1 := unmarshal(&on)
	if err1 != nil {
		return err1
	}
	n.ComponentMap = make(map[string]Components)
	for _, i := range on.ListOfComponents {
		n.ComponentMap[i.ComponentName] = i
	}

	return nil
}

When I run the config.NamespaceMap it gives the following

map[:{NamespaceName: K8sNamespace: ComponentMap:map[comp1:{ComponentName:comp1 NumShards:0 NumReplicas:1 Port:0 EpochLength:0}]}]

If you want to do such transformation you will need to write a customized UnmarshalYAML() receiver on types Config and Namespace. Here is basic working example of doing so (only for "namespaces"):

type Config struct {
	Namespaces map[string]Namespace `yaml:"namespaces"`
}

// Replace go-yaml built-in unmarshaller with custom that will transform list to map.
// Note this code is meant only as demonstration!
func (c *Config) UnmarshalYAML(unmarshal func(interface{}) error) error {
	type origConfig struct {
		Namespaces []Namespace `yaml:"namespaces"`
	}
	var o origConfig
	err := unmarshal(&o)
	if err != nil {
		return err
	}

    // Assign namespaces in list to map; namespaces with same name will be overwritten
	c.Namespaces = make(map[string]Namespace)
	for _, n := range o.Namespaces {
		c.Namespaces[n.Namespace] = n
	}
	return nil
}

// You can use "Config" type as usual
func main() {
	var config Config
	err := yaml.Unmarshal(<your_yaml>, &config)
	if err != nil {
		log.Panic(err)
	}
	fmt.Println(config.Namespaces)
    // map[default:{default k8s} ns2:{ns2 }]
	fmt.Printf("%v\n", config.Namespaces["default"])
    // {default k8s}
}

As noted in code example this will cause some problems (e.g. what to do if namespace names are same?).

Playground link: https://go.dev/play/p/IKg8kmRnknq