KeyValueMapOperations नीति

आपको Apigee Edge का दस्तावेज़ दिख रहा है.
Apigee X के दस्तावेज़ पर जाएं. जानकारी

क्या

यह Apigee Edge में उपलब्ध Key Value Map (KVM) स्टोर को नीति के आधार पर ऐक्सेस करने की सुविधा देता है. की/वैल्यू पेयर को नाम वाले मौजूदा मैप में सेव किया जा सकता है, वापस पाया जा सकता है, और मिटाया जा सकता है. इसके लिए, KeyValueMapOperations नीतियों को कॉन्फ़िगर करना होता है. इन नीतियों में PUT, GET या DELETE ऑपरेशन के बारे में बताया जाता है. (नीति के तहत, इनमें से कम से कम एक कार्रवाई की जानी चाहिए.)

वीडियो

केवीएम के बारे में ज़्यादा जानने के लिए, ये वीडियो देखें.

सैंपल

<KeyValueMapOperations async="false" continueOnError="false" enabled="true" name="FooKVM" mapIdentifier="FooKVM">
  <DisplayName>FooKVM</DisplayName>
  <ExpiryTimeInSecs>86400</ExpiryTimeInSecs>
  <Scope>environment</Scope>
  <Put>
    <Key>
      <Parameter>FooKey_1</Parameter>
    </Key>
    <Value>foo</Value>
    <Value>bar</Value>
  </Put>
</KeyValueMapOperations>

<KeyValueMapOperations mapIdentifier="FooKVM" async="false" continueOnError="false" enabled="true" name="GetKVM">
  <DisplayName>GetKVM</DisplayName>
  <ExpiryTimeInSecs>86400</ExpiryTimeInSecs>
  <Scope>environment</Scope>
  <Get assignTo="foo_variable" index="2">
    <Key>
      <Parameter>FooKey_1</Parameter>
    </Key>
  </Get>
</KeyValueMapOperations>

<KeyValueMapOperations name="putUrl" mapIdentifier="urlMapper">
   <Scope>apiproxy</Scope>
   <Put override="true">
      <Key>
         <Parameter ref="urlencoding.requesturl.hashed"/>
      </Key>
      <Value ref="urlencoding.longurl.encoded"/>
      <Value ref="request.queryparam.url"/>
   </Put>
</KeyValueMapOperations>

{
    "entry" :[
        {
            "name" : "ed24e12820f2f900ae383b7cc4f2b31c402db1be",
            "value" : "http://tinyurl.com/38lwmlr,http://apigee.com"
        }
    ],
    "name" : "urlMapper"
}

<KeyValueMapOperations name="getUrl" mapIdentifier="urlMapper">
   <Scope>apiproxy</Scope>
   <Get assignTo="urlencoding.shorturl" index='1'>
      <Key>
         <Parameter ref="urlencoding.requesturl.hashed"/>
      </Key>
   </Get>
</KeyValueMapOperations>

<KeyValueMapOperations name="getEncrypted" mapIdentifier="encrypted_map">
   <Scope>apiproxy</Scope>
   <Get assignTo="private.encryptedVar" index='1'>
      <Key>
         <Parameter>foo</Parameter>
      </Key>
   </Get>
</KeyValueMapOperations>

एलिमेंट का रेफ़रंस

इस एलिमेंट रेफ़रंस में, KeyValueMapOperations नीति के एलिमेंट और एट्रिब्यूट के बारे में बताया गया है:

<KeyValueMapOperations async="false" continueOnError="false"
    enabled="true" name="Key-Value-Map-Operations-1"
    mapIdentifier="urlMapper" >
   <DisplayName>Key Value Map Operations 1</DisplayName>
   <Scope>environment</Scope>
   <ExpiryTimeInSecs>300</ExpiryTimeInSecs>
   <InitialEntries>
      <Entry>
         <Key>
            <Parameter>key_name_literal</Parameter>
         </Key>
         <Value>value_literal</Value>
      </Entry>
      <Entry>
         <Key>
            <Parameter>variable_name</Parameter>
         </Key>
         <Value>value_1_literal</Value>
         <Value>value_2_literal</Value>
      </Entry>
   </InitialEntries>
   <Put override="false">
      <Key>
         <Parameter>key_name_literal</Parameter>
      </Key>
      <Value ref="variable_name"/>
   </Put>
   <Get assignTo="myvar" index="1">
      <Key>
         <Parameter ref="variable_name"/>
      </Key>
   </Get>
   <Delete>
      <Key>
         <Parameter>key_name_literal</Parameter>
      </Key>
   </Delete>
</KeyValueMapOperations>

<KeyValueMapOperations> एट्रिब्यूट

यहां दिए गए उदाहरण में, <KeyValueMapOperations> टैग के एट्रिब्यूट दिखाए गए हैं:

<KeyValueMapOperations async="false" continueOnError="false" enabled="true" name="Key-Value-Map-Operations-1" mapIdentifier="map_name">

यहां दी गई टेबल में, <KeyValueMapOperations> टैग से जुड़े एट्रिब्यूट के बारे में बताया गया है:

यहां दी गई टेबल में, ऐसे एट्रिब्यूट के बारे में बताया गया है जो नीति के सभी पैरंट एलिमेंट में एक जैसे होते हैं:

&lt;DisplayName&gt; एलिमेंट

इस कॉलम में नीति को लेबल करने के लिए, name एट्रिब्यूट के साथ-साथ इस्तेमाल करें मैनेजमेंट यूज़र इंटरफ़ेस (यूआई) प्रॉक्सी एडिटर, जिसका नाम अलग और सामान्य भाषा में है.

<DisplayName>Policy Display Name</DisplayName>

<Delete> एलिमेंट

यह कुकी, तय किए गए की/वैल्यू पेयर को मिटाती है. <Get>, <Put> या <Delete> में से कम से कम एक का इस्तेमाल करना ज़रूरी है.

पैरंट एलिमेंट पर mapIdentifier एट्रिब्यूट का इस्तेमाल करके, केवीएम का नाम ज़रूर बताएं. उदाहरण के लिए:

<Delete>
   <Key>
      <Parameter>key_name_literal</Parameter>
   </Key>
</Delete>

<Entry> एलिमेंट

कुंजी के हिसाब से वैल्यू मैप करने के लिए सीड वैल्यू. ये वैल्यू, कुंजी के हिसाब से वैल्यू मैप करने की सुविधा शुरू होने पर, कुंजी के हिसाब से वैल्यू मैप करने की सुविधा में अपने-आप भर जाती हैं.

Edge for Public Cloud के लिए, कुंजी का साइज़ 2 केबी तक सीमित है. उदाहरण के लिए:

<InitialEntries>
   <Entry>
      <Key>
         <Parameter>key_name_literal</Parameter>
      </Key>
      <Value>v1</Value>
   </Entry>
   <Entry>
      <Key>
         <Parameter>key_name_variable</Parameter>
      </Key>
      <Value>v3</Value>
      <Value>v4</Value>
   </Entry>
</InitialEntries>

<ExclusiveCache> एलिमेंट

समर्थन नहीं होना या रुकना. इसके बजाय, <Scope> एलिमेंट का इस्तेमाल करें.

<ExpiryTimeInSecs> एलिमेंट

इससे वह अवधि तय होती है जिसके बाद Edge, तय किए गए केवीएम से अपनी कैश मेमोरी में सेव की गई वैल्यू को रीफ़्रेश करता है.

इस एलिमेंट को शामिल न करने पर या इसकी वैल्यू 0 या -1 होने पर, 300 सेकंड की डिफ़ॉल्ट वैल्यू का इस्तेमाल किया जाता है. उदाहरण के लिए:

<ExpiryTimeInSecs>600</ExpiryTimeInSecs>

केवीएम, लंबे समय तक डेटा बनाए रखने का एक तरीका है. यह कुंजियों और वैल्यू को NoSQL डेटाबेस में सेव करता है. इस वजह से, रनटाइम के दौरान KVM से डेटा पढ़ने पर, प्रॉक्सी की परफ़ॉर्मेंस धीमी हो सकती है. परफ़ॉर्मेंस को बेहतर बनाने के लिए, Edge में एक ऐसा सिस्टम मौजूद है जो रनटाइम के दौरान, मेमोरी में KVM कुंजियों/वैल्यू को कैश मेमोरी में सेव करता है. यह KVM Operations नीति, GET कार्रवाइयों के लिए हमेशा कैश मेमोरी से डेटा पढ़ती है.

<ExpiryTimeInSecs> एलिमेंट की मदद से, यह कंट्रोल किया जा सकता है कि नीति में इस्तेमाल की गई कुंजियों/वैल्यू को KVM से फिर से रीफ़्रेश करने से पहले, कैश मेमोरी में कितने समय तक सेव रखा जाए. हालांकि, GET और PUT ऑपरेशन, कैश मेमोरी के खत्म होने की अवधि पर अलग-अलग तरह से असर डालते हैं.

GET - KVM GET ऑपरेशन के पहली बार चालू होने पर, KVM से अनुरोध की गई कुंजियां/वैल्यू, कैश मेमोरी में लोड हो जाती हैं. KVM का नाम, नीति के रूट mapIdentifier एट्रिब्यूट में दिया गया होता है. ये कुंजियां/वैल्यू, कैश मेमोरी में तब तक रहती हैं, जब तक इनमें से कोई एक कार्रवाई नहीं हो जाती:

• <ExpiryTimeInSecs> में तय की गई सेकंड की संख्या खत्म हो जाती है.
  या
• KVM नीति में PUT ऑपरेशन, मौजूदा वैल्यू को बदल देता है. इसके बारे में यहां बताया गया है.

PUT - PUT ऑपरेशन, तय किए गए KVM में कुंजियां/वैल्यू लिखता है. अगर PUT अनुरोध से ऐसी कुंजी में डेटा लिखा जाता है जो पहले से ही कैश मेमोरी में मौजूद है, तो कैश मेमोरी तुरंत रीफ़्रेश हो जाती है. अब इसमें नीति के <ExpiryTimeInSecs> एलिमेंट में तय किए गए समय के लिए, नई वैल्यू सेव हो जाती है.

उदाहरण - केवीएम को कैश मेमोरी में सेव करना

1. GET ऑपरेशन,"rating" की वैल्यू को वापस पाता है. इससे कैश मेमोरी में "10" वैल्यू जुड़ जाती है. नीति के उल्लंघन के लिए <ExpiryTimeInSecs> का स्कोर 60 है.
2. तीस सेकंड बाद, GET नीति फिर से लागू होती है और कैश मेमोरी से "10" को वापस लाती है.
3. पांच सेकंड बाद, PUT नीति "rating" की वैल्यू को "8" पर अपडेट करती है. साथ ही, PUT नीति पर <ExpiryTimeInSecs> 20 है. नई वैल्यू के साथ कैश मेमोरी को तुरंत रीफ़्रेश किया जाता है. अब इसे 20 सेकंड तक कैश मेमोरी में सेव रखा जाएगा. (अगर PUT अनुरोध नहीं किया गया होता, तो पहली बार GET अनुरोध करने पर पॉप्युलेट की गई कैश मेमोरी, अगले 30 सेकंड तक मौजूद रहती. यह 60 सेकंड की ओरिजनल अवधि में से बची हुई अवधि होती.)
4. पंद्रह सेकंड बाद, एक और GET अनुरोध भेजा जाता है और "8" की वैल्यू वापस मिलती है.

<Get> एलिमेंट

बताई गई कुंजी के लिए वैल्यू वापस लाता है. <Get>, <Put> या <Delete> में से कम से कम एक का इस्तेमाल करना ज़रूरी है.

पैरंट एलिमेंट पर mapIdentifier एट्रिब्यूट का इस्तेमाल करके, केवीएम का नाम ज़रूर बताएं.

किसी नीति में एक से ज़्यादा Get ब्लॉक शामिल किए जा सकते हैं, ताकि KVM से एक से ज़्यादा आइटम वापस पाए जा सकें.

किसी केवीएम से एक आइटम पाना

<Get assignTo="myvar" index="1">
   <Key>
      <Parameter>key_name_literal</Parameter>
   </Key>
</Get>

किसी केवीएम से एक से ज़्यादा आइटम पाना

इस उदाहरण में, मान लें कि KVM में ये कुंजियां और वैल्यू मौजूद हैं. इसके अलावा, KVM में अब तक की सबसे लोकप्रिय फ़िल्मों की सूची सेव होती है. साथ ही, इसमें सभी मुख्य फ़िल्मों के निर्देशक का नाम भी सेव होता है.

यहां KVM की नीति का कॉन्फ़िगरेशन दिया गया है. इसका इस्तेमाल करके, हम मौजूदा समय में सबसे ज़्यादा लोकप्रिय फ़िल्म और उसके निर्देशक का नाम पा सकते हैं:

<Get assignTo="top.movie.pick" index="1">
   <Key>
      <Parameter>top_movies</Parameter>
   </Key>
</Get>
<Get assignTo="movie.director">
   <Key>
      <Parameter ref="top.movie.pick"/>
   </Key>
</Get>

एपीआई प्रॉक्सी को कॉल करने पर, Edge ये वैरिएबल बनाता है. इनका इस्तेमाल एपीआई प्रॉक्सी फ़्लो में किया जा सकता है:

• top.movie.pick=Princess Bride
• movie.director=Rob Reiner

विशेषताएं

यहां दी गई टेबल में, <Get> एलिमेंट के एट्रिब्यूट के बारे में बताया गया है:

<Get assignTo="private.myvar">

<InitialEntries> एलिमेंट

कुंजी के हिसाब से वैल्यू मैप करने के लिए सीड वैल्यू. ये वैल्यू, कुंजी के हिसाब से वैल्यू मैप करने की सुविधा शुरू होने पर पॉप्युलेट होती हैं. पैरंट एलिमेंट पर mapIdentifier एट्रिब्यूट के साथ केवीएम का नाम ज़रूर बताएं. उदाहरण के लिए:

<InitialEntries>
   <Entry>
      <Key>
         <Parameter>key_name_literal</Parameter>
      </Key>
      <Value>v1</Value>
   </Entry>
   <Entry>
      <Key>
         <Parameter>key_name_variable</Parameter>
      </Key>
      <Value>v3</Value>
      <Value>v4</Value>
   </Entry>
</InitialEntries>

इस एलिमेंट का इस्तेमाल करने पर, जब डिप्लॉय किए गए प्रॉक्सी के वर्शन पर मैनेजमेंट यूज़र इंटरफ़ेस(यूआई) में नीति सेव की जाती है या इस एलिमेंट के साथ नीति वाला एपीआई प्रॉक्सी बंडल डिप्लॉय किया जाता है, तो KVM में कुंजियां अपने-आप बन जाती हैं. ये कुंजियां, एन्क्रिप्ट (सुरक्षित) नहीं की जाती हैं. अगर नीति में दी गई वैल्यू, केवीएम में दी गई वैल्यू से अलग हैं, तो प्रॉक्सी डिप्लॉय होने पर केवीएम में दी गई वैल्यू बदल जाती हैं. नई कुंजियां/वैल्यू, मौजूदा KVM में मौजूदा कुंजियों/वैल्यू के साथ जोड़ दी जाती हैं.

इस एलिमेंट से भरी गई कुंजियां और वैल्यू, लिटरल होनी चाहिए. उदाहरण के लिए, इस एलिमेंट में <Parameter ref="request.queryparam.key"> का इस्तेमाल नहीं किया जा सकता.

Edge for the Public Cloud और Edge for the Private Could, दोनों के लिए कुंजी का साइज़ 2 केबी से ज़्यादा नहीं होना चाहिए. केवीएम की वैल्यू 2 केबी से ज़्यादा नहीं होनी चाहिए.

सुरक्षित किया गया KVM बनाने के लिए, Key/Value Maps management API का इस्तेमाल करें.

<Key> एलिमेंट

यह कुंजी/वैल्यू मैप एंट्री में मौजूद कुंजी के बारे में बताता है. कुंजी कंपोज़िट हो सकती है. इसका मतलब है कि कुंजी बनाने के लिए, एक से ज़्यादा पैरामीटर जोड़े जा सकते हैं. उदाहरण के लिए, userID और role को मिलाकर key बनाया जा सकता है. उदाहरण के लिए:

<Key>
    <Parameter>key_name_literal</Parameter>
</Key>

कुंजी का नाम सेट करने के बारे में खास जानकारी के लिए, <Parameter> एलिमेंट देखें.

Edge for Public Cloud में, कुंजी का साइज़ 2 केबी तक सीमित होता है. ज़्यादा जानकारी के लिए, सार्वजनिक क्लाउड एपीआई और निजी क्लाउड एपीआई के Edge के बीच अंतर देखें.

<Parameter> एलिमेंट

यह की/वैल्यू पेयर में मौजूद कुंजी के बारे में बताता है. यह एलिमेंट, की/वैल्यू पेयर को बनाते, डालते, वापस पाते या मिटाते समय नाम तय करता है.

नाम बताने के लिए, इनका इस्तेमाल किया जा सकता है:

• लिटरल स्ट्रिंग

  <Key>
    <Parameter>literal</Parameter>
  </Key>

• यह एक ऐसा वैरिएबल है जिसे रन टाइम में वापस पाया जा सकता है. इसके लिए, ref एट्रिब्यूट का इस्तेमाल किया जाता है

  <Key>
    <Parameter ref="variable_name"/>
  </Key>

• लिटरल और वैरिएबल रेफ़रंस का कॉम्बिनेशन

  <Key>
    <Parameter>targeturl</Parameter>
    <Parameter ref="apiproxy.name"/>
    <Parameter>weight</Parameter>
  </Key>

जब Key एलिमेंट में कई Parameter एलिमेंट शामिल होते हैं, तो असरदार कुंजी स्ट्रिंग, हर पैरामीटर की वैल्यू को स्ट्रिंग जोड़ने की प्रोसेस से मिलती है. इसमें दो अंडरस्कोर शामिल होते हैं. उदाहरण के लिए, ऊपर दिए गए उदाहरण में, अगर apiproxy.name वैरिएबल की वैल्यू "abc1" है, तो असरदार कुंजी targeturl__abc1__weight होगी.

चाहे आपको कोई मुख्य/वैल्यू एंट्री मिल रही हो, अपडेट करनी हो या मिटानी हो, मुख्य वैल्यू मैप में मौजूद मुख्य वैल्यू के नाम से मुख्य वैल्यू का नाम मेल खाना चाहिए. दिशा-निर्देशों के लिए, कुंजी के नाम तय करना और उन्हें वापस पाना लेख पढ़ें.

विशेषताएं

यहां दी गई टेबल में, <Parameter> एलिमेंट के एट्रिब्यूट के बारे में बताया गया है:

<Put> एलिमेंट

यह फ़ंक्शन, किसी की/वैल्यू पेयर को की वैल्यू वाले मैप में लिखता है. इससे कोई फ़र्क़ नहीं पड़ता कि की वैल्यू वाला मैप एन्क्रिप्ट (सुरक्षित) किया गया है या नहीं. अगर पैरंट एलिमेंट पर मौजूद mapIdentifier एट्रिब्यूट में दिया गया मुख्य वैल्यू मैप मौजूद नहीं है, तो मैप अपने-आप बन जाता है. हालांकि, यह मैप एन्क्रिप्ट (सुरक्षित) नहीं होता. अगर मुख्य वैल्यू मैप पहले से मौजूद है, तो उसमें मुख्य वैल्यू जोड़ दी जाती है.

एन्क्रिप्ट किया गया की वैल्यू मैप बनाने के लिए, Key/Value Maps management API का इस्तेमाल करें. इसके अलावा, यूआई में एन्क्रिप्ट किए गए एनवायरमेंट-स्कोप वाले केवीएम बनाने के लिए, एनवायरमेंट के लिए की वैल्यू मैप बनाना और उनमें बदलाव करना लेख पढ़ें.

<Put override="false">
   <Key>
      <Parameter ref="mykeyvar"/>
   </Key>
   <Value ref="myvalvar1"/>
</Put>

विशेषताएं

यहां दी गई टेबल में, <Put> एलिमेंट के एट्रिब्यूट के बारे में बताया गया है:

<Scope> एलिमेंट

यह मुख्य वैल्यू वाले मैप के लिए, सुलभता की सीमा तय करता है. डिफ़ॉल्ट स्कोप environment होता है. इसका मतलब है कि डिफ़ॉल्ट रूप से, मैप की एंट्री को किसी एनवायरमेंट (जैसे, टेस्ट या प्रॉड) में चल रही सभी एपीआई प्रॉक्सी के साथ शेयर किया जाता है. अगर स्कोप को apiproxy पर सेट किया जाता है, तो कुंजी वैल्यू मैप में मौजूद एंट्री सिर्फ़ उस एपीआई प्रॉक्सी से ऐक्सेस की जा सकती हैं जो मैप में वैल्यू लिखती है.

ध्यान दें कि किसी मैप या मैप एंट्री को ऐक्सेस करते समय, आपको वही स्कोप वैल्यू देनी होगी जिसका इस्तेमाल मैप बनाते समय किया गया था. उदाहरण के लिए, अगर मैप को apiproxy स्कोप के साथ बनाया गया था, तो आपको उसकी वैल्यू वापस पाने, उसमें बदलाव करने या एंट्री मिटाने के लिए, apiproxy स्कोप का इस्तेमाल करना होगा.

<Scope>environment</Scope>

<Value> एलिमेंट

इससे किसी कुंजी की वैल्यू के बारे में पता चलता है. वैल्यू को लिटरल स्ट्रिंग के तौर पर या ref एट्रिब्यूट का इस्तेमाल करके, रन टाइम में वापस पाने के लिए वैरिएबल के तौर पर तय किया जा सकता है:

<!-- Specify a literal value -->
<Value>literal<Value>

या:

<!-- Specify the name of variable value to be populated at run time. -->
<Value ref="variable_name"/>

एक से ज़्यादा <Value> एलिमेंट शामिल करके, कई हिस्सों वाली वैल्यू भी तय की जा सकती है. वैल्यू को रन टाइम में जोड़ा जाता है.

यहां दिए गए उदाहरण में, KVM में दो कुंजियां जोड़ी गई हैं:

• v1,v2 वैल्यू वाली मुख्य वैल्यू k1
• v3,v4 वैल्यू वाली मुख्य वैल्यू k2

<InitialEntries>
   <Entry>
      <Key>
         <Parameter>k1</Parameter>
      </Key>
      <Value>v1</Value>
      <Value>v2</Value>
   </Entry>
   <Entry>
      <Key>
         <Parameter>k2</Parameter>
      </Key>
      <Value>v3</Value>
      <Value>v4</Value>
   </Entry>
</InitialEntries>

यहां दिए गए उदाहरण में, दो वैल्यू के साथ एक कुंजी बनाई गई है. मान लें कि संगठन का नाम foo_org, एपीआई प्रॉक्सी का नाम bar, और एनवायरमेंट test है:

• bar,test वैल्यू वाली मुख्य वैल्यू foo_org

<Put>
    <Key>
        <Parameter ref="organization.name"/>
    </Key>
    <Value ref="apiproxy.name"/>
    <Value ref="environment.name"/>
</Put>

विशेषताएं

यहां दी गई टेबल में, <Value> एलिमेंट के एट्रिब्यूट के बारे में बताया गया है:

गड़बड़ी की जानकारी

Edge की नीतियों से मिली गड़बड़ियों का फ़ॉर्मैट एक जैसा होता है. इसके बारे में गड़बड़ी के कोड का रेफ़रंस में बताया गया है.

यह सेक्शन गड़बड़ी के कोड और दिखाए गए गड़बड़ी के मैसेज के बारे में बताता है. साथ ही, इस नीति के ट्रिगर होने पर Edge की मदद से सेट की गई गड़बड़ी के वैरिएबल के बारे में बताता है. यह जानकारी जानना ज़रूरी है कि क्या गड़बड़ियों को ठीक करने के लिए, गड़बड़ी से जुड़े नियम बनाए जा रहे हैं. ज़्यादा जानने के लिए, नीति से जुड़ी गड़बड़ियों के बारे में आपके लिए ज़रूरी जानकारी और गड़बड़ियों को ठीक करने के तरीके देखें.

रनटाइम से जुड़ी गड़बड़ियां

नीति के लागू होने पर ये गड़बड़ियां हो सकती हैं.

डिप्लॉयमेंट से जुड़ी गड़बड़ियां

ये गड़बड़ियां तब हो सकती हैं, जब इस नीति वाले किसी प्रॉक्सी को डिप्लॉय किया जाता है.

स्कीमा

इस्तेमाल की जानकारी

की वैल्यू मैप की खास जानकारी के लिए, की वैल्यू मैप का इस्तेमाल करना लेख पढ़ें.

की वैल्यू मैप स्टोर, की/वैल्यू पेयर के तौर पर फ़ॉर्मैट किए गए डेटा के लिए, डेटा को बनाए रखने का एक आसान तरीका उपलब्ध कराता है. इन्हें रनटाइम के दौरान, नीतियों या कोड के ज़रिए ऐक्सेस किया जा सकता है. मैप में key=value फ़ॉर्मैट में कोई भी डेटा मौजूद है.

उदाहरण के लिए, localhost=127.0.0.1, zip_code=94110 या first_name=felix. पहले उदाहरण में, localhost एक कुंजी है और 127.0.0.1 एक वैल्यू है. हर की/वैल्यू पेयर को की वैल्यू मैप में एक एंट्री के तौर पर सेव किया जाता है. मुख्य वैल्यू मैप में कई एंट्री सेव की जा सकती हैं.

यहां की-वैल्यू मैप इस्तेमाल करने का एक उदाहरण दिया गया है. मान लें कि आपको अलग-अलग बैकएंड एनवायरमेंट से जुड़े आईपी पतों की सूची सेव करनी है. ipAddresses नाम का की वैल्यू मैप बनाया जा सकता है. इसमें की/वैल्यू पेयर की सूची को एंट्री के तौर पर शामिल किया जा सकता है. उदाहरण के लिए, इस JSON से ऐसा मैप बनाया जा सकता है:

{
  "entry" : [ {
    "name" : "Development",
    "value" : "65.87.18.18"
  }, {
    "name" : "Staging",
    "value" : "65.87.18.22"
  } ],
  "name" : "ipAddresses"
}

इस स्ट्रक्चर का इस्तेमाल, आईपी पतों का ऐसा स्टोर बनाने के लिए किया जा सकता है जिसका इस्तेमाल नीतियां रनटाइम में कर सकती हैं. जैसे, आईपी पतों को अनुमति देने या अस्वीकार करने की सूची लागू करने के लिए, बैकएंड टारगेट पते को डाइनैमिक तरीके से चुनने के लिए वगैरह. आम तौर पर, KeyValueMapOperations नीति का इस्तेमाल, लंबे समय तक इस्तेमाल की जा सकने वाली जानकारी को सेव करने या वापस पाने के लिए किया जाता है. इस जानकारी को कई अनुरोध/जवाब वाले लेन-देन में फिर से इस्तेमाल करना होता है.

KeyValueMapOperations नीति का इस्तेमाल करके या सीधे तौर पर Apigee Edge Management API का इस्तेमाल करके, कुंजी/वैल्यू मैप में बदलाव किया जा सकता है. संगठन के लिए कुंजी/वैल्यू मैप एपीआई एपीआई के बारे में ज़्यादा जानने के लिए, मैनेजमेंट एपीआई का संदर्भ देखें. एपीआई का इस्तेमाल इन कामों के लिए किया जा सकता है. उदाहरण के लिए, कुंजी/वैल्यू स्टोर में बड़े डेटा सेट अपलोड करना या कुंजी/वैल्यू मैप की एंट्री मैनेज करने के लिए स्क्रिप्ट बनाना. KeyValueMapOperations नीति का इस्तेमाल करके एपीआई को ऐक्सेस करने से पहले, आपको एपीआई के साथ एक कुंजी/वैल्यू मैप बनाना होगा.

कुंजी के नाम तय करना और उन्हें वापस पाना

<Parameter> और <Value> एलिमेंट की मदद से, लिटरल वैल्यू (जहां वैल्यू, ओपनिंग और क्लोज़िंग टैग के बीच होती है) तय की जा सकती है. इसके अलावा, ref एट्रिब्यूट का इस्तेमाल करके, उस वैरिएबल का नाम तय किया जा सकता है जिसकी वैल्यू का इस्तेमाल रनटाइम में किया जाना चाहिए.

पैरामीटर एलिमेंट का खास तौर पर ज़िक्र किया जाना चाहिए, क्योंकि यह उस कुंजी का नाम तय करता है जिसे बनाया जाता है. साथ ही, यह उस कुंजी का नाम भी तय करता है जिसे आपको वापस पाना है या मिटाना है. यहां दो उदाहरण दिए गए हैं. पहले उदाहरण में, कुंजी का नाम सीधे तौर पर बताया गया है. वहीं, दूसरे उदाहरण में वैरिएबल का इस्तेमाल करके कुंजी का नाम बताया गया है. मान लें कि KVM में कुंजियां बनाने के लिए, इनका इस्तेमाल किया जाता है:

<Parameter>key_name_literal</Parameter>
<Parameter ref="key.name.variable"/>

पहले उदाहरण में, "key_name_literal" की लिटरल वैल्यू को KVM में कुंजी के नाम के तौर पर सेव किया जाता है. दूसरे इंस्टेंस में, key.name.variable में मौजूद वैल्यू, KVM में कुंजी का नाम बन जाती है. उदाहरण के लिए, अगर key.name.variable में foo वैल्यू शामिल है, तो कुंजी का नाम "foo" होगा.

जब आपको GET ऑपरेशन की मदद से कुंजी और उसकी वैल्यू वापस लानी हो या DELETE ऑपरेशन की मदद से मिटानी हो, तब <Parameter> सेटिंग का नाम, KVM में मौजूद कुंजी के नाम से मेल खाना चाहिए. उदाहरण के लिए, अगर KVM में कुंजी का नाम "foo" है, तो <Parameter>foo</Parameter> का इस्तेमाल करके, लिटरल वैल्यू तय की जा सकती है. इसके अलावा, "foo" वैल्यू वाला कोई वैरिएबल भी तय किया जा सकता है. जैसे: <Parameter ref="variable.containing.foo"/>.

मिलते-जुलते विषय

• संगठन के लिए कुंजी/वैल्यू मैप करने वाला एपीआई