You can use the field [+] notation to append fields in yq v3. So your command results in

yq --style double w -i myfile.yaml 'spec.template.spec.containers[0].command[+]' "c"

The above command appends the entry "c" to the array.

Or if you want to update the whole array command you could do in v4. Note that this creates the array entries in separate lines than what is shown in the OP. See YAML Multi-Line Arrays

yq e '.spec.template.spec.containers[0].command |= ["a", "b", "c","d"] | ..style="double"' yaml

Note that yq v4 is already out there and supports much powerful path expressions and operations. See Upgrading from v3 for instructions

Use this:

yq -i '.persons[0].city = "Barcelona"' yourfile.yaml

replacing “Barcelona” and yourfile.yaml as appropriate. This replaces the value of city inside the first element of the persons array (or creates it if there is none).

Note: Please raise future how to questions under discussion please :)

yq '._anchors_ += loadstr("cert.txt") | (._anchors_[-1] anchor="_myVar")' data.yaml

Explanation:

• You need to append to the _anchors_ array: ._anchors_ =+ (blah)
• Load contents as a string from a file loadstr("cert.txt")
• Next add the anchor to the new element. We do this by selecting the last element in the array, and assign it an anchor: (._anchors_[-1] anchor="_myVar")

I don't have enough rep to comment on your answer @kev - but that is super neat. I'm going to clean it up a little and put it into the tips and tricks in the yq docs.

I've made it a little more generic and put it all in one command:

yq ea '.services = (
  ((.services[] | {.name: .}) as $item ireduce ({}; . * $item )) as $uniqueMap
  | ( $uniqueMap  | to_entries | .[]) as $item ireduce([]; . + $item.value)
) | select(fi==0)' *.yaml

Disclosure: I wrote yq

I just realized that my solution only worked for kislyuk/yq.

yq -y '.set += (.set | map(select(.x == "a") | .x = "A"))'

For mikefarah/yq go with @Fravadona's solution

yq '.set as $set | .set += ($set | map(select(.x=="a") | .x = "A"))'

Both output:

set:
  - x: a
    y: aaa
  - x: b
    y: bbb
  - x: a
    y: ccc
  - x: A
    y: aaa
  - x: A
    y: ccc

You can either make name and mountPath appear on the same level:

yq '.volumes += [{"name": "sys", "mountPath": "/sys"}]' test.yaml

volumes:
  - name: var-log
    hostPath:
      path: /var/log
  - name: dev-log
    hostPath:
      path: /dev/log
  - name: sys
    mountPath: /sys

Or you can make them nested, lacking the "jointing" value:

yq '.volumes += [{"name": {"mountPath": "/sys"}}]' test.yaml

volumes:
  - name: var-log
    hostPath:
      path: /var/log
  - name: dev-log
    hostPath:
      path: /dev/log
  - name:
      mountPath: /sys

The following is an expression for Mike Farah's yq that loads the name from cen1.yaml and puts it into the internal yq variable $name. It then creates a new YAML document and loads cen2.yaml into it, under the key given by $name:

load("cen1.yaml").name as $name | .[$name] = load("cen2.yaml")

We can use this to loop over several subdirectories, applying yq in each, and collecting the output in final.yaml. The code assumes that the directories all match the filename globbing pattern directory_*:

for dir in directory_*; do
(
    cd "$dir" &&
    yq -n 'load("cen1.yaml").name as $name | .[$name] = load("cen2.yaml")'
)
done >final.yaml

We use -n with yq since we don't use any files given on the command line.

Given the data in your question (corrected by removing the dotted lines and inserting spaces after each :), this would produce the following YAML file:

xxxx:
  service: ser1
  image:
    field1: field1
    field2: field2
another:
  tv: lcd
  name:
    field1: field1
    field2: field2

If all directories are not available at once, you can build your final.yaml file by appending bits to it:

rm -f final.yaml

# Get directory_1, and then...
(
    cd directory_1 &&
    yq -n 'load("cen1.yaml").name as $name | .[$name] = load("cen2.yaml")'
) >>final.yaml

# Get directory_2, and then...
(
    cd directory_2 &&
    yq -n 'load("cen1.yaml").name as $name | .[$name] = load("cen2.yaml")'
) >>final.yaml

# etc.

... essentially running each iteration of the loop manually and appending the output to the result file in each step.

The same thing, but with Andrey Kislyuk's yq (a wrapper around jq):

for dir in directory_*; do
(
    cd "$dir" &&
    yq -n -y 'input.name as $name | .[$name] = inputs' cen1.yaml cen2.yaml
)
done >final.yaml