KeyValueMapOperations नीति

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

यह क्या है

यह Apigee Edge में मौजूद 'की वैल्यू मैप' (केवीएम) स्टोर को नीति के हिसाब से ऐक्सेस करने की सुविधा देता है. कुंजी/वैल्यू पेयर को मौजूदा मैप में सेव किया जा सकता है, वापस लाया जा सकता है, और मिटाया जा सकता है. ऐसा करने के लिए, 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> टैग के खास एट्रिब्यूट के बारे में बताया गया है:

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

<DisplayName> एलिमेंट

मैनेजमेंट यूज़र इंटरफ़ेस (यूआई) प्रॉक्सी एडिटर में, आम भाषा के अलग नाम से नीति को लेबल करने के लिए, 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>

<खास कैश> एलिमेंट

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

<ExpiryTimeInSecs> एलिमेंट

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

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

<ExpiryTimeInSecs>600</ExpiryTimeInSecs>

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

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

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

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

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

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

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

<Get> एलिमेंट

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

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

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

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

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

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

यहां दिए गए उदाहरण में, नीचे दी गई कुंजियों और वैल्यू वाली केवीएम मान लें. अब तक की सबसे लोकप्रिय फ़िल्मों की चल रही सूची को सेव करने के अलावा, केवीएम सभी बड़ी फ़िल्मों के लिए निर्देशक का नाम भी स्टोर करता है.

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

<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>

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

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

एट्रिब्यूट

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

<Get assignTo="private.myvar">

<UrlEntries> एलिमेंट

की-वैल्यू मैप के लिए सीड वैल्यू, जिन्हें इनीशियल शुरू होने पर 'की-वैल्यू मैप' में भरा जाता है. पैरंट एलिमेंट पर 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>

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

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

सार्वजनिक क्लाउड के लिए Edge और प्राइवेट जा सकता है, दोनों के लिए कुंजी का साइज़ 2 केबी तक सीमित होता है. केवीएम की वैल्यू 2 केबी तक सीमित है.

एन्क्रिप्ट (सुरक्षित) किया गया केवीएम बनाने के लिए, कुंजी/वैल्यू मैप मैनेजमेंट एपीआई का इस्तेमाल करें.

<कुंजी> एलिमेंट

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

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

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

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

<पैरामीटर> एलिमेंट

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

आपके पास इनका इस्तेमाल करके नाम तय करने का विकल्प होता है:

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

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

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

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

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

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

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

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

एट्रिब्यूट

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

<पुट> एलिमेंट

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

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

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

एट्रिब्यूट

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

<Scope> एलिमेंट

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

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

<Scope>environment</Scope>

<वैल्यू> एलिमेंट

कुंजी की वैल्यू बताता है. वैल्यू को लिटरल स्ट्रिंग के तौर पर या 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> एलिमेंट भी शामिल किए जा सकते हैं. रन टाइम के दौरान वैल्यू को जोड़ा जाता है.

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

• 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 एक value है. हर कुंजी/वैल्यू पेयर को की-वैल्यू मैप में एंट्री के तौर पर सेव किया जाता है. की-वैल्यू मैप में कई एंट्री सेव की जा सकती हैं.

यहां की-वैल्यू मैप इस्तेमाल करने का उदाहरण दिया गया है. मान लें कि आपको अलग-अलग बैकएंड एनवायरमेंट से जुड़े आईपी पतों की सूची सेव करनी है. आपके पास 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 एट्रिब्यूट का इस्तेमाल करके, किसी ऐसे वैरिएबल का नाम तय किया जा सकता है जिसकी वैल्यू रनटाइम के दौरान इस्तेमाल की जानी चाहिए.

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

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

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

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

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

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