Aws-cli: मैं टैग मान के सबस्ट्रिंग से मेल करके उदाहरण फ़िल्टर करना चाहता हूं

यह निश्चित रूप से एक मुश्किल है! मैंने इसे निम्नलिखित अभिव्यक्ति के साथ प्रबंधित किया:

"Reservations[].Instances[?Tags[?Key == 'Data' && contains(Value, 'foo=yes')][]][].InstanceId"

यह एक लंबा है, इसलिए मैं इसे टुकड़े-टुकड़े कर दूंगा। शुरुआत के लिए, आइए इस नमूना डेटा का उपयोग करें:

{
    "Reservations": [{"Instances": [
        {
            "InstanceId": "id-target1",
            "Tags": [
                {"Key": "Data", "Value": "foo=yes,bar=no"},
                {"Key": "Name", "Value": "target"}
            ]
        },
        {
            "InstanceId": "id-target2",
            "Tags": [
                {"Key": "Data", "Value": "foo=yes,bar=yes"},
                {"Key": "Name", "Value": "target"}
            ]
        },
        {
            "InstanceId": "id-invalid1",
            "Tags": [
                {"Key": "Data", "Value": "foo=no,bar=no"},
                {"Key": "Name", "Value": "invalid"}
            ]
        },
        {
            "InstanceId": "id-invalid2",
            "Tags": [
                {"Key": "Data", "Value": "foo=no,bar=yes"},
                {"Key": "Name", "Value": "invalid"}
            ]
        }
    ]}]
}

सबसे पहले, हम इंस्टेंस सूची प्राप्त करना चाहते हैं, इसलिए हम Reservations[].Instances[] :

[
  {
    "Tags": [
      {
        "Value": "foo=yes,bar=no",
        "Key": "Data"
      },
      {
        "Value": "target",
        "Key": "Name"
      }
    ],
    "InstanceId": "id-target1"
  },
  {
    "Tags": [
      {
        "Value": "foo=yes,bar=yes",
        "Key": "Data"
      },
      {
        "Value": "target",
        "Key": "Name"
      }
    ],
    "InstanceId": "id-target2"
  },
  {
    "Tags": [
      {
        "Value": "foo=no,bar=no",
        "Key": "Data"
      },
      {
        "Value": "invalid",
        "Key": "Name"
      }
    ],
    "InstanceId": "id-invalid1"
  },
  {
    "Tags": [
      {
        "Value": "foo=no,bar=yes",
        "Key": "Data"
      },
      {
        "Value": "invalid",
        "Key": "Name"
      }
    ],
    "InstanceId": "id-invalid2"
  }
]

अब हम टैग चाहते हैं जिसमें "डेटा" मान के साथ एक कुंजी है: .Tags[?Key == 'Data'] पूर्ण अभिव्यक्ति Reservations[].Instances[].Tags[?Key == 'Data'] और परिणाम के लिए:

[
  [
    {
      "Value": "foo=yes,bar=no",
      "Key": "Data"
    }
  ],
  [
    {
      "Value": "foo=yes,bar=yes",
      "Key": "Data"
    }
  ],
  [
    {
      "Value": "foo=no,bar=no",
      "Key": "Data"
    }
  ],
  [
    {
      "Value": "foo=no,bar=yes",
      "Key": "Data"
    }
  ]
]

अब हम यह भी चाहते हैं कि उस टैग का मान "foo=yes" हो, इसलिए हम पूर्ण अभिव्यक्ति Reservations[].Instances[].Tags[?Key == 'Data' && contains(Value, 'foo=yes')] और परिणाम के लिए शर्त && contains(Value, 'foo=yes') जोड़ते हैं:

[
  [
    {
      "Value": "foo=yes,bar=no",
      "Key": "Data"
    }
  ],
  [
    {
      "Value": "foo=yes,bar=yes",
      "Key": "Data"
    }
  ],
  [],
  []
]

ठीक है, अब पूर्ण अभिव्यक्ति Reservations[].Instances[].Tags[?Key == 'Data' && contains(Value, 'foo=yes')][] और परिणाम के लिए उस सूची को [] साथ समतल करें:

[
  {
    "Value": "foo=yes,bar=no",
    "Key": "Data"
  },
  {
    "Value": "foo=yes,bar=yes",
    "Key": "Data"
  }
]

ठीक है, तो अब हमारे पास वे टैग हैं जो हम चाहते हैं, लेकिन हम पूर्ण इंस्टेंस डेटा क्या चाहते हैं। तो चलिए उस टैग फ़िल्टर को इंस्टेंस पर फ़िल्टर के रूप में वापस ले जाते हैं। तो परिणाम के साथ अब पूर्ण अभिव्यक्ति Reservations[].Instances[?Tags[?Key == 'Data' && contains(Value, 'foo=yes')][]] :

[
  [
    {
      "Tags": [
        {
          "Value": "foo=yes,bar=no",
          "Key": "Data"
        },
        {
          "Value": "target",
          "Key": "Name"
        }
      ],
      "InstanceId": "id-target1"
    },
    {
      "Tags": [
        {
          "Value": "foo=yes,bar=yes",
          "Key": "Data"
        },
        {
          "Value": "target",
          "Key": "Name"
        }
      ],
      "InstanceId": "id-target2"
    }
  ]
]

थोड़ा और समझाने के लिए, ? एक सच्चे मूल्य की जाँच कर रहा है। उन उदाहरणों के लिए जिनके पास उचित टैग नहीं है, ?Tags[?Key == 'Data' && contains(Value, 'foo=yes')][] वापस किया जाएगा null , एक मिथ्या मान।

अब बस इतना करना बाकी है कि उस सूची को समतल करें और पूर्ण अभिव्यक्ति "Reservations[].Instances[?Tags[?Key == 'Data' && contains(Value, 'foo=yes')][]][].InstanceId" और परिणाम के लिए [].InstanceId साथ इंस्टेंस आईडी का चयन करें:

[
  "id-target1",
  "id-target2"
]

और हम कर रहे हैं!

बहुत बढ़िया! Tags[?Key == 'Data' && contains(Value, 'foo=yes')] कदम वह जगह है जहां मैं पटरी से उतर गया। शुक्रिया!

* अपडेट करें *

मेरे उद्देश्यों के लिए, निम्नलिखित एक बहुत आसान दृष्टिकोण था (यह वही है जो मुझे 2+ साल पहले के धागे तक पहुंचने से मिलता है):

--filter "Name=tag:aws:cloudformation:stack-name,Values=*$1*"
* वास्तविक सन्देश *

यह अब काम नहीं कर रहा प्रतीत होता है। इसने अंतिम चरण तक काम किया, जहां [?टैग को .tags के लिए प्रतिस्थापित किया गया था।
Reservations[].Instances[].Tags[?Key == 'aws:cloudformation:stack-name' && contains(Value, 'target')][]