You don't need to use --yaml-output flag, which tries to parse the output of the filter defined as a YAML entity. For getting the raw strings, use a filter in the JSON context itself

yq -r '.images.tags[]'

keys is a built-in function in jq when given an object, returns its keys in an array. So it is not actually apart of your yaml (not a property) which means you cannot do services.keys.

To get the keys you can do the following when using Python yq:

We will get the object of services in the first part then we pass it to keys which will return a list of keys based on a given object

cat docker-compose.yml | yq '.services | keys'

Or like this (without cat and pipe):

yq '.services | keys' docker-compose.yml

The output will be:

[
  "apache",
  "mysql",
  "php"
]

To get rid of the brackets:

yq '.services | keys[]' docker-compose.yml

The output:

"apache"
"mysql"
"php"

For more about details you can check Builtin operators and functions in jq. Note that yq is a wrapper for jq so the documentation of jq would be helpful as the help of yq recommends.

On Go yq you can do

yq e '.services | keys'

You could switch to kislyuk's yq which uses native jq under the hood. Then, you would just need to_entries to access key and value, string interpolation in combination with the -r flag to produce the output, and @sh to escape for shell compliance:

yq -r 'to_entries[] | "export \(.key)=\(.value | @sh)"'

export FOO='somefoo'
export BAR='somebar'

The trick is to convert the object into an array, apply the selection to the array elements and then convert it back into an object. The filter with_entries does these conversions under the hood. It is a shorthand for to_entries | map(foo) | from_entries (see jq manual).

The call is slightly different depending on the yq implementation used: yq - Python or yq - Go. The bash script contains calls for both implementations.

#!/bin/bash

INPUT='
{
  "entries": {
    "entry1": {
      "enabled": true
    },
    "entry2": {
      "enabled": false
    },
    "entry3": {
      "dummy": "TEST"
    }
  }
}
'

echo "yq - Go implementation"       # https://mikefarah.gitbook.io/yq/
yq -j e '.entries | with_entries(select(.value.enabled == true))' - <<< "$INPUT"

echo "yq - Python implementation"   # https://github.com/kislyuk/yq
yq '.entries | with_entries(select(.value.enabled == true))' <<< "$INPUT"

output

{
  "entry1": {
    "enabled": true
  }
}

Sorry didn't see all the attention here, @tony-sol you can do it like this:

yq '.[] |= pick(["name", "status"])' data1.yaml

Explanation:

• You want to pick particular fields from each map in the array
• .[] |= will match each element in the array, and update that element w.r.t itself
• pick([]) will take a given map and pick fields (omitting the rest)

See https://mikefarah.gitbook.io/yq/operators/pick for details.

The different with doing .[] | (.name, .status) is that will match all elements and just pulling out just those values.

First example:

yq '.[] | select(.[] == "c")' examples/data1.yaml

Explanation:

• expand the top level entries .[]
• select the ones that have a (direct) child == "foo": select(.[] == "c")

second example:

yq '.[] | select(.. == "foo")' examples/data1.yaml

Explanation:

• expand the top level entries .[]
• select the ones that have a any child == "foo": select(.. == "c") (recursively checks the tree)

Not sure which output is desired - this is outputting the child values of the nodes. You could pipe it through 'key' to get the key node...

With mikfarah/yq it should be pretty straightforward. Select the required object with the select() expression and access the required field with the dot notation

yq '.accounts[] | select(.account_id == "XXXXXXXX").deploy_iam' < accounts.yml