นโยบาย KeyValueMapOperations

คุณกำลังดูเอกสารประกอบของ Apigee Edge
ไปที่เอกสารประกอบของ Apigee X
info

ไอคอนการดำเนินการแมปค่าคีย์จาก Edge UI

อะไร

ให้สิทธิ์เข้าถึงที่เก็บแมปค่าคีย์ (KVM) ตามนโยบายที่มีใน Apigee Edge จัดเก็บ เรียกข้อมูล และลบคู่คีย์/ค่าจากแมปที่มีชื่ออยู่ได้โดยการกำหนดค่านโยบาย KeyValueMapOperations ที่ระบุการดำเนินการ PUT, GET หรือ DELETE (นโยบายต้องดำเนินการอย่างน้อย 1 อย่างต่อไปนี้)

วิดีโอ

ดูข้อมูลเพิ่มเติมเกี่ยวกับ KVM ได้ในวิดีโอต่อไปนี้

วิดีโอ คำอธิบาย
เหตุใดจึงต้องใช้ Key Value Maps ดูเหตุผลที่คุณต้องใช้ KVM และวิธีการทำงาน
สร้าง KVM โดยใช้ UI และเรียกข้อมูล KVM ที่รันไทม์ สร้าง KVM เรียกค่าโดยใช้นโยบาย KVM และแทรกค่าลงในคำขอ API โดยใช้ตัวแปรโฟลว์
สร้างและอัปเดต KVM ที่รันไทม์ของ API สร้าง KVM ที่รันไทม์ของ API โดยใช้นโยบาย KVM
แคช KVM เพื่อ เพิ่มประสิทธิภาพ ปรับปรุงประสิทธิภาพของนโยบาย KVM โดยการแคชข้อมูล
จัดเก็บข้อมูลที่เข้ารหัส KVM จัดเก็บข้อมูลที่ละเอียดอ่อนใน KVM ในรูปแบบที่เข้ารหัสและเรียกค่าที่ รันไทม์โดยใช้นโยบาย KVM และตัวแปรส่วนตัว
จัดการการเข้าถึง โดยใช้ขอบเขต KVM จำกัด KVM ให้กับองค์กร สภาพแวดล้อม พร็อกซี API หรือการแก้ไขพร็อกซี API โดยใช้แอตทริบิวต์ขอบเขตนโยบาย KVM
ลบรายการ KVM ที่รันไทม์ของ API ลบรายการ KVM ที่รันไทม์ของ API โดยใช้การดำเนินการ DELETE ของนโยบาย KVM

ตัวอย่าง

PUT KVM ที่มีลิเทอรัล

เมื่อนโยบายต่อไปนี้ทํางาน จะสร้าง KVM ที่เข้ารหัสชื่อ FooKVM จากนั้นสร้างคีย์ชื่อ FooKey_1 โดยมี ค่า 2 ค่าที่ตั้งค่าด้วยสตริงตามตัวอักษร foo และ bar (ไม่ได้ตั้งค่าด้วยค่าที่ดึงมาจากตัวแปร) เมื่อคุณ GETคีย์ในตัวอย่างถัดไป คุณจะระบุหมายเลขดัชนี เพื่อดึงค่าที่ต้องการ

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

โปรดทราบว่าขอบเขตคือ "สภาพแวดล้อม" ซึ่งหมายความว่าคุณจะเห็น KVM ใน UI การจัดการ ในส่วน API > การกำหนดค่าสภาพแวดล้อม > Key Value Map KVM ที่แสดงในหน้านั้นทั้งหมดมีขอบเขตเป็นสภาพแวดล้อมที่เลือก

รับ KVM จากค่าคงที่

นโยบายนี้จะดูFooKVMจากตัวอย่างก่อนหน้า รับค่าที่ 2 (ดัชนี="2") จากคีย์ FooKey_1 และจัดเก็บไว้ในตัวแปรที่ชื่อ foo_variable

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

PUT KVM ที่มีตัวแปร

ตัวอย่างง่ายๆ ของแผนที่ค่าคีย์ที่มีประโยชน์คือบริการย่อ URL สามารถกำหนดค่าแผนที่ค่าคีย์ เพื่อจัดเก็บ URL แบบย่อพร้อมกับ URL แบบเต็มที่เกี่ยวข้อง

ตัวอย่างนโยบายนี้สร้างแมปค่าคีย์ นโยบายจะวางคีย์ที่มีค่าที่เชื่อมโยง 2 ค่า ลงในแผนที่คีย์/ค่าที่ชื่อ "urlMapper"

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

คีย์ในตัวอย่างนี้ urlencoding.requesturl.hashed เป็นตัวอย่างของ ตัวแปรที่กำหนดเอง โค้ด (เช่น JavaScript หรือ Java) จะสร้าง URL ของคำขอที่แฮชแล้ว จากนั้นจะจัดเก็บไว้ในตัวแปรนี้ ซึ่งนโยบาย KeyValueMapOperations จะเข้าถึงได้

สำหรับแต่ละคีย์ requesturl.hashed ระบบจะจัดเก็บค่า 2 ค่า ได้แก่

  • เนื้อหาของตัวแปรที่กำหนดเองชื่อ urlencoding.longurl.encoded
  • เนื้อหาของตัวแปรที่กำหนดไว้ล่วงหน้า request.queryparam.url

ตัวอย่างเช่น เมื่อนโยบายทํางานในรันไทม์ ค่าของตัวแปรอาจเป็นดังนี้

  • urlencoding.requesturl.hashed: ed24e12820f2f900ae383b7cc4f2b31c402db1be
  • urlencoding.longurl.encoded: http://tinyurl.com/38lwmlr
  • request.queryparam.url: http://apigee.com

ระบบจะสร้างแมปคีย์/ค่าและรายการต่อไปนี้ในที่เก็บคีย์/ค่าของ Edge และ กำหนดขอบเขตให้กับพร็อกซี API ที่แนบนโยบายไว้

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

รายการจะยังคงอยู่จนกว่าจะถูกลบ รายการที่จัดเก็บคีย์/ค่าจะกระจายอยู่ในอินสแตนซ์ของ Edge ที่เรียกใช้ระบบคลาวด์

รับ KVM จากตัวแปร

ตัวอย่างง่ายๆ ของแผนที่ค่าคีย์ที่มีประโยชน์คือบริการ "ย่อ" URL สามารถกำหนดค่าแผนที่ค่าคีย์ เพื่อจัดเก็บ URL แบบย่อพร้อมกับ URL แบบเต็มที่เกี่ยวข้อง

หากต้องการดึงค่าของรายการในแมปค่าคีย์ เช่น รายการที่กล่าวถึงในแท็บ PUT ของ KeyValueMapOperations ให้กำหนดค่านโยบายเพื่อรับแมปค่าคีย์ ดังนี้

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

เมื่อมีการดำเนินการตามนโยบายนี้ หากค่าของตัวแปร urlencoding.requesturl.hashed เป็น ed24e12820f2f900ae383b7cc4f2b31c402db1be ระบบจะตั้งค่าตัวแปรที่กำหนดเองชื่อ urlencoding.shorturl เป็นค่า http://tinyurl.com/38lwmlr

เมื่อดึงข้อมูลมาแล้ว นโยบายและโค้ดอื่นๆ จะเข้าถึงข้อมูลได้โดยการดึงค่าจากตัวแปรเหล่านั้น

รับค่าที่เข้ารหัสจาก KVM

หากมีการเข้ารหัสแผนที่ค่าคีย์ ให้เรียกค่าโดยใช้คำนำหน้า "private." ในค่าแอตทริบิวต์ assignTo ในตัวอย่างนี้ ตัวแปร private.encryptedVar จะเก็บค่าที่ถอดรหัสแล้วของคีย์ foo ในแผนที่คีย์-ค่า ดูข้อมูลเกี่ยวกับการสร้างแผนที่ค่าคีย์ที่เข้ารหัสได้ที่หัวข้อ "สร้าง" ของ Key/Value Maps Management API

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

แอตทริบิวต์ คำอธิบาย ค่าเริ่มต้น การมีบุคคลอยู่
mapIdentifier

ระบุตัวระบุที่จะใช้เมื่อเข้าถึงแผนที่ที่สร้างขึ้นโดยนโยบายนี้ หรือใน UI การจัดการ

ชื่อ KVM จะคำนึงถึงตัวพิมพ์เล็กและตัวพิมพ์ใหญ่ใน Apigee Edge สำหรับ Public Cloud เช่น foobar จะแตกต่างจาก FooBar

หากคุณยกเว้นแอตทริบิวต์นี้ ระบบจะใช้ KVM ที่ชื่อ kvmap

ภายในขอบเขตขององค์กร/สภาพแวดล้อม/API Proxy คุณสามารถใช้แอตทริบิวต์ mapIdentifier เพื่อระบุชื่อแผนที่ของคุณเองได้

ไม่มี ไม่บังคับ

ตารางต่อไปนี้อธิบายแอตทริบิวต์ทั่วไปในองค์ประกอบระดับบนสุดของนโยบายทั้งหมด

แอตทริบิวต์ คำอธิบาย ค่าเริ่มต้น การมีบุคคลอยู่
name

ชื่อภายในของนโยบาย ค่าของแอตทริบิวต์ name สามารถ ประกอบด้วยตัวอักษร ตัวเลข การเว้นวรรค ขีดกลางสั้น ขีดล่าง และจุด ค่านี้ไม่สามารถ เกิน 255 อักขระ

(ไม่บังคับ) ใช้องค์ประกอบ <DisplayName> เพื่อติดป้ายกำกับนโยบายใน เครื่องมือแก้ไขพร็อกซี UI การจัดการด้วยชื่อที่เป็นภาษาธรรมชาติต่างกัน

ไม่มี ต้องระบุ
continueOnError

ตั้งค่าเป็น false เพื่อแสดงผลข้อผิดพลาดเมื่อนโยบายล้มเหลว เป็นเรื่องปกติ พฤติกรรมสำหรับนโยบายส่วนใหญ่

ตั้งค่าเป็น true เพื่อให้ดำเนินการตามขั้นตอนได้อย่างต่อเนื่องแม้จะมีนโยบายแล้วก็ตาม ล้มเหลว

เท็จ ไม่บังคับ
enabled

ตั้งค่าเป็น true เพื่อบังคับใช้นโยบาย

ตั้งค่าเป็น false เพื่อปิดนโยบาย นโยบายจะไม่ บังคับใช้ แม้ว่าจะยังคงแนบกับขั้นตอน

จริง ไม่บังคับ
async

แอตทริบิวต์นี้เลิกใช้งานแล้ว

เท็จ เลิกใช้

&lt;DisplayName&gt; องค์ประกอบ

ใช้เพิ่มเติมจากแอตทริบิวต์ name เพื่อติดป้ายกำกับนโยบายใน เครื่องมือแก้ไขพร็อกซี UI การจัดการด้วยชื่อที่เป็นภาษาธรรมชาติต่างกัน

<DisplayName>Policy Display Name</DisplayName>
ค่าเริ่มต้น

ไม่มี

หากไม่ใส่องค์ประกอบนี้ ค่าของแอตทริบิวต์ name ของนโยบายจะเป็น

การมีบุคคลอยู่ ไม่บังคับ
ประเภท สตริง

องค์ประกอบ <Delete>

ลบคู่คีย์/ค่าที่ระบุ ต้องใช้ <Get> <Put> หรือ <Delete> อย่างน้อย 1 รายการ

อย่าลืมระบุชื่อของ KVM ด้วยแอตทริบิวต์ mapIdentifier ในองค์ประกอบระดับบน เช่น

<Delete>
   <Key>
      <Parameter>key_name_literal</Parameter>
   </Key>
</Delete>
ค่าเริ่มต้น ไม่มี
การมีบุคคลอยู่ ต้องระบุหากไม่มี <Get> หรือ <Put>
ประเภท ไม่มี

องค์ประกอบ <Entry>

ค่าเริ่มต้นสําหรับแผนที่คีย์-ค่า ซึ่งจะป้อนข้อมูลในแผนที่คีย์-ค่าเมื่อมีการ เริ่มต้น

สำหรับ Edge for Public Cloud ระบบจะจำกัดขนาดคีย์ไว้ที่ 2 KB เช่น

<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 รีเฟรชค่าที่แคชจาก KVM ที่ระบุ

ค่า 0 หรือ -1 หรือการยกเว้นองค์ประกอบนี้หมายความว่าระบบจะใช้ค่าเริ่มต้น 300 วินาที เช่น

<ExpiryTimeInSecs>600</ExpiryTimeInSecs>
ค่าเริ่มต้น 300 (5 นาที)
การมีบุคคลอยู่ ไม่บังคับ
ประเภท จำนวนเต็ม

KVM เป็นกลไกการคงอยู่ระยะยาวที่จัดเก็บคีย์และค่าในฐานข้อมูล NoSQL ด้วยเหตุนี้ การอ่านจาก KVM ในรันไทม์จึงอาจทำให้ประสิทธิภาพของพร็อกซีช้าลง Edge มีกลไกในตัวสำหรับการแคชคีย์/ค่า KVM ในหน่วยความจำระหว่างรันไทม์เพื่อปรับปรุงประสิทธิภาพ นโยบายการดำเนินการ KVM นี้จะอ่านจากแคชสำหรับการดำเนินการ GET เสมอ

องค์ประกอบ <ExpiryTimeInSecs> ช่วยให้คุณควบคุมระยะเวลาที่จะจัดเก็บคีย์/ค่า ที่ใช้ในนโยบายไว้ในแคชก่อนที่จะรีเฟรชจาก KVM อีกครั้ง อย่างไรก็ตาม การดำเนินการ GET และ PUT มีผลต่อการหมดอายุของแคชแตกต่างกัน

GET - เมื่อการดำเนินการ KVM GET ทำงานเป็นครั้งแรก ระบบจะโหลดคีย์/ค่าที่ขอจาก KVM (ซึ่งมีชื่อระบุไว้ในแอตทริบิวต์รูทของนโยบาย mapIdentifier ) ลงในแคช โดยจะอยู่ในแคชสำหรับการดำเนินการ GET ครั้งต่อๆ ไปจนกว่าจะเกิดเหตุการณ์ต่อไปนี้

  • <ExpiryTimeInSecs> วินาทีที่ระบุจะหมดอายุ
    หรือ
  • การดำเนินการ PUT ในนโยบาย KVM จะเขียนทับค่าที่มีอยู่ (อธิบายถัดไป)

PUT - การดำเนินการ PUT จะเขียนคีย์/ค่าไปยัง KVM ที่ระบุ หาก PUT เขียนไปยังคีย์ที่มีอยู่ในแคชอยู่แล้ว ระบบจะรีเฟรชแคชนั้นทันทีและแคชจะเก็บ ค่าใหม่เป็นจำนวนวินาทีที่ระบุไว้ในองค์ประกอบ <ExpiryTimeInSecs> ของนโยบาย

ตัวอย่าง - การแคช KVM

  1. การดำเนินการ GET จะดึงค่าของ "rating" ซึ่งจะเพิ่มค่า "10" ลงในแคช โดย <ExpiryTimeInSecs> ของนโยบายนี้คือ 60
  2. หลังจากนั้น 30 วินาที นโยบาย GET จะทำงานอีกครั้งและดึง "10" จากแคช
  3. 5 วินาทีต่อมา นโยบาย PUT จะอัปเดตค่าของ "rating" เป็น "8" และ <ExpiryTimeInSecs> ในนโยบาย PUT คือ 20 ระบบจะรีเฟรชแคชทันที ด้วยค่าใหม่ ซึ่งตอนนี้ตั้งค่าให้ยังอยู่ในแคชเป็นเวลา 20 วินาที (หากไม่มีการเรียกใช้ PUT แคชที่สร้างขึ้นครั้งแรกโดยการเรียกใช้ GET ครั้งแรกจะยังคงอยู่ต่อไปอีก 30 วินาที ซึ่งเป็นส่วนที่เหลือจาก 60 วินาทีแรก)
  4. 15 วินาทีต่อมา GET อีกรายการจะดำเนินการและเรียกค่า "8"

องค์ประกอบ <Get>

ดึงค่าสำหรับคีย์ที่ระบุ ต้องใช้ <Get> <Put> หรือ <Delete> อย่างน้อย 1 รายการ

อย่าลืมระบุชื่อของ KVM ด้วยแอตทริบิวต์ mapIdentifier ในองค์ประกอบระดับบน

คุณสามารถใส่บล็อก Get หลายบล็อกในนโยบายเพื่อดึงข้อมูลหลายรายการ จาก KVM

ค่าเริ่มต้น ไม่มี
การมีบุคคลอยู่ ต้องระบุหากไม่มี <Put> หรือ <Delete>
ประเภท ไม่มี

รับรายการเดียวจาก KVM

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

รับรายการหลายรายการจาก KVM

ในตัวอย่างต่อไปนี้ ให้สมมติว่า KVM มีคีย์และค่าต่อไปนี้ นอกจากจะจัดเก็บรายการภาพยนตร์ยอดนิยมตลอดกาลแล้ว KVM ยังจัดเก็บชื่อผู้กำกับของภาพยนตร์สำคัญทั้งหมดด้วย

คีย์ ค่า
top_movies The Princess Bride,The Godfather,Citizen Kane
พลเมืองคาน Orson Welles
เจ้าหญิงแต่งงาน ร็อบ ไรเนอร์
The Godfather ฟรานซิส ฟอร์ด คอปโปลา

นี่คือการกำหนดค่านโยบาย 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>

เมื่อมีการเรียกพร็อกซี API, Edge จะสร้างตัวแปรต่อไปนี้ ซึ่งคุณใช้ได้ในโฟลว์พร็อกซี API

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

Attributes

ตารางต่อไปนี้อธิบายแอตทริบิวต์ขององค์ประกอบ <Get>

แอตทริบิวต์ คำอธิบาย ค่าเริ่มต้น การมีบุคคลอยู่
assignTo

ตัวแปรที่จะกำหนดค่าที่ดึงมา

หากแมปค่าคีย์ได้รับการเข้ารหัส ให้เริ่มชื่อ assignTo ด้วย "private." เช่น

<Get assignTo="private.myvar">

นโยบายจะแสดงข้อผิดพลาดหากคุณพยายามดึงข้อมูลแมปค่าคีย์ที่เข้ารหัสโดยไม่ใช้คำนำหน้า คำนำหน้าซึ่งจำเป็นสำหรับวัตถุประสงค์ด้านความปลอดภัยขั้นพื้นฐานในระหว่างการแก้ไขข้อบกพร่องจะซ่อนค่าที่เข้ารหัสจากเซสชันการติดตามและแก้ไขข้อบกพร่องของพร็อกซี API

ดูข้อมูลเกี่ยวกับการสร้างแมปค่าคีย์ที่เข้ารหัสได้ที่หัวข้อ "สร้าง" ของ การจัดการแมปคีย์/ค่า API และการสร้างและ แก้ไขแมปค่าคีย์ของสภาพแวดล้อม

ไม่มี ต้องระบุ
ดัชนี

หมายเลขดัชนี (ในดัชนีแบบ 1) ของรายการที่จะดึงข้อมูลจากคีย์ที่มีหลายค่า เช่น การระบุ index=1 จะแสดงผลค่าแรกและกำหนดให้กับตัวแปร assignTo หากไม่ได้ระบุค่าดัชนี ระบบจะกำหนดค่าทั้งหมดของ รายการนั้นให้กับตัวแปรเป็น java.util.List

ดูตัวอย่างได้ที่แท็บ "รับค่าที่เข้ารหัสจาก KVM" ในตัวอย่าง

ไม่มี ไม่บังคับ

องค์ประกอบ <InitialEntries>

ค่าเริ่มต้นสำหรับแผนที่คีย์-ค่า ซึ่งจะป้อนในแผนที่คีย์-ค่าเมื่อเริ่มต้น อย่าลืมระบุชื่อของ KVM ด้วยแอตทริบิวต์ 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>

เมื่อใช้องค์ประกอบนี้ เมื่อคุณบันทึกนโยบายใน UI การจัดการในพร็อกซีเวอร์ชันที่ใช้งานจริง หรือเมื่อคุณทําการติดตั้งใช้งานชุดพร็อกซี API ที่มีนโยบายที่มีองค์ประกอบนี้ ระบบจะสร้างคีย์ใน KVM โดยอัตโนมัติ (แบบไม่ได้เข้ารหัส) หากค่าในนโยบายแตกต่างจากค่าใน KVM ระบบจะเขียนทับค่าใน KVM เมื่อมีการติดตั้งใช้งานพร็อกซี ระบบจะเพิ่มคีย์/ค่าใหม่ลงใน KVM ที่มีอยู่พร้อมกับคีย์/ค่าที่มีอยู่

คีย์และค่าที่ป้อนโดยองค์ประกอบนี้ต้องเป็นค่าลิเทอรัล เช่น ระบบไม่รองรับ <Parameter ref="request.queryparam.key"> ในองค์ประกอบนี้

ขนาดคีย์จำกัดไว้ที่ 2 KB สำหรับทั้ง Edge สำหรับ Public Cloud และ Edge สำหรับ Private Cloud ค่า KVM มีขนาดไม่เกิน 2 KB

หากต้องการสร้าง KVM ที่เข้ารหัส ให้ใช้ Key/Value Maps Management API

ค่าเริ่มต้น ไม่มี
การมีบุคคลอยู่ ไม่บังคับ
ประเภท ไม่มี

องค์ประกอบ <Key>

ระบุคีย์ในรายการแมปคีย์/ค่า คีย์อาจเป็นแบบรวม ซึ่งหมายความว่าสามารถเพิ่มพารามิเตอร์มากกว่า 1 รายการเพื่อสร้างคีย์ได้ เช่น userID และ role อาจรวมกันเพื่อสร้าง key เช่น

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

โปรดดูองค์ประกอบ <Parameter> เพื่อดูรายละเอียดเกี่ยวกับวิธี ตั้งชื่อคีย์

เมื่อใช้ Edge สำหรับระบบคลาวด์สาธารณะ ระบบจะจำกัดขนาดคีย์ไว้ที่ 2 KB ดูข้อมูลเพิ่มเติมได้ที่ความแตกต่างระหว่าง Edge สำหรับ Public Cloud API กับ Private Cloud API

ค่าเริ่มต้น ไม่มี
การมีบุคคลอยู่ ไม่บังคับ
ประเภท ไม่มี

องค์ประกอบ <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>

เมื่อองค์ประกอบคีย์มีองค์ประกอบพารามิเตอร์หลายรายการ สตริงคีย์ที่มีผลคือ การเชื่อมโยงค่าของแต่ละพารามิเตอร์เข้าด้วยกันโดยใช้ขีดล่างคู่ ตัวอย่างเช่น ในตัวอย่างข้างต้น หากตัวแปร apiproxy.name มีค่า "abc1" คีย์ที่มีผลจะเป็น targeturl__abc1__weight

ไม่ว่าคุณจะรับ อัปเดต หรือลบรายการคีย์/ค่า ชื่อคีย์ต้องตรงกับชื่อของคีย์ในแผนที่คีย์-ค่า ดูหลักเกณฑ์ได้ที่การระบุและ การดึงชื่อคีย์

ค่าเริ่มต้น ไม่มี
การมีบุคคลอยู่ ต้องระบุ
ประเภท สตริง

Attributes

ตารางต่อไปนี้อธิบายแอตทริบิวต์ขององค์ประกอบ <Parameter>

แอตทริบิวต์ คำอธิบาย ค่าเริ่มต้น การมีบุคคลอยู่
ref ระบุชื่อของตัวแปรที่มีค่าเป็นชื่อที่แน่นอนของคีย์ที่คุณ ต้องการสร้าง รับ หรือลบ ไม่มี ต้องระบุหากไม่มีค่าลิเทอรัลระหว่างแท็กเปิดและ แท็กปิด ห้ามใช้หากระบุค่าลิเทอรัล

องค์ประกอบ <Put>

เขียนคู่คีย์/ค่าลงในแมปค่าคีย์ ไม่ว่าแมปค่าคีย์จะเข้ารหัสหรือไม่ก็ตาม หากไม่มีแผนที่คีย์-ค่าที่ระบุในแอตทริบิวต์ mapIdentifier ในองค์ประกอบระดับบน ระบบจะสร้างแผนที่โดยอัตโนมัติ (เป็นแบบไม่เข้ารหัส) หากมีแมปค่าคีย์ อยู่แล้ว ระบบจะเพิ่มคีย์/ค่าลงในแมปนั้น

หากต้องการสร้างแมปค่าคีย์ที่เข้ารหัส ให้ใช้ Key/Value Maps Management API หรือดูการสร้างและแก้ไขแมปค่าคีย์ของสภาพแวดล้อม เพื่อสร้าง KVM ที่เข้ารหัสซึ่งมีขอบเขตระดับสภาพแวดล้อมใน UI

<Put override="false">
   <Key>
      <Parameter ref="mykeyvar"/>
   </Key>
   <Value ref="myvalvar1"/>
</Put>
ค่าเริ่มต้น ไม่มี
การมีบุคคลอยู่ ต้องระบุหากไม่มี <Get> หรือ <Delete>
ประเภท ไม่มี

Attributes

ตารางต่อไปนี้อธิบายแอตทริบิวต์ขององค์ประกอบ <Put>

แอตทริบิวต์ คำอธิบาย ค่าเริ่มต้น การมีบุคคลอยู่
ลบล้าง

หากตั้งค่าเป็น true จะลบล้างค่าของคีย์

false ไม่บังคับ

องค์ประกอบ <Scope>

กำหนดขอบเขตของการช่วยเหลือพิเศษสำหรับแผนที่ค่าคีย์ ขอบเขตเริ่มต้นคือ environment ซึ่งหมายความว่าโดยค่าเริ่มต้น พร็อกซี API ทั้งหมดจะแชร์รายการแผนที่ ที่ทำงานในสภาพแวดล้อม (เช่น test หรือ prod) หากตั้งค่าขอบเขตเป็น apiproxy เฉพาะพร็อกซี API ที่ เขียนค่าลงในแผนที่เท่านั้นที่จะเข้าถึงรายการในแผนที่ค่าคีย์ได้

โปรดทราบว่าเมื่อเข้าถึงแผนที่หรือรายการแผนที่ คุณต้องระบุค่าขอบเขตเดียวกันกับที่ใช้ เมื่อสร้างแผนที่ เช่น หากสร้างแผนที่ด้วยขอบเขต apiproxy คุณต้องใช้ขอบเขต apiproxy เมื่อเรียกค่า ใส่การเปลี่ยนแปลง หรือลบรายการ

<Scope>environment</Scope>
ค่าเริ่มต้น environment
การมีบุคคลอยู่ ไม่บังคับ
ประเภท สตริง
ค่าที่ถูกต้อง:
  • organization
  • environment
  • apiproxy
  • policy (การแก้ไขพร็อกซี API)

องค์ประกอบ <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> หลายรายการเพื่อระบุค่าแบบหลายส่วนได้ด้วย ระบบจะรวมค่าที่รันไทม์

ในตัวอย่างต่อไปนี้ มีการเพิ่มคีย์ 2 รายการลงใน KVM

  • คีย์ k1 ที่มีค่า v1,v2
  • คีย์ k2 ที่มีค่า v3,v4
<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>

ในตัวอย่างต่อไปนี้ ระบบจะสร้างคีย์ 1 รายการที่มีค่า 2 ค่า สมมติว่าชื่อองค์กรคือ foo_org ชื่อพร็อกซี API คือ bar และสภาพแวดล้อมคือ test

  • คีย์ foo_org ที่มีค่า bar,test
<Put>
    <Key>
        <Parameter ref="organization.name"/>
    </Key>
    <Value ref="apiproxy.name"/>
    <Value ref="environment.name"/>
</Put>
ค่าเริ่มต้น ไม่มี
การมีบุคคลอยู่ ต้องระบุ
ประเภท สตริง

Attributes

ตารางต่อไปนี้อธิบายแอตทริบิวต์ขององค์ประกอบ <Value>

แอตทริบิวต์ คำอธิบาย ค่าเริ่มต้น การมีบุคคลอยู่
ref ระบุชื่อตัวแปรที่มีค่าซึ่งมีค่าคีย์ที่คุณต้องการ ตั้งค่า ไม่มี ต้องระบุหากไม่มีค่าลิเทอรัลระหว่างแท็กเปิดและ แท็กปิด ห้ามใช้หากระบุค่าลิเทอรัล

ข้อมูลอ้างอิงข้อผิดพลาด

ข้อผิดพลาดที่แสดงจากนโยบาย Edge จะเป็นไปตามรูปแบบที่สอดคล้องกันตามที่อธิบายไว้ในข้อมูลอ้างอิงรหัสข้อผิดพลาด

ส่วนนี้จะอธิบายโค้ดข้อผิดพลาดและข้อความแสดงข้อผิดพลาดที่แสดงผลและตัวแปรข้อผิดพลาดที่ Edge กําหนดเมื่อนโยบายนี้ทําให้เกิดข้อผิดพลาด ข้อมูลนี้เป็นสิ่งสำคัญที่ต้องทราบหากคุณกำลังกำหนดกฎข้อผิดพลาดเพื่อจัดการกับข้อผิดพลาด ดูข้อมูลเพิ่มเติมได้ที่สิ่งที่คุณต้องทราบเกี่ยวกับข้อผิดพลาดของนโยบายและการจัดการข้อผิดพลาด

ข้อผิดพลาดเกี่ยวกับรันไทม์

ข้อผิดพลาดเหล่านี้อาจเกิดขึ้นเมื่อนโยบายทำงาน

รหัสข้อผิดพลาด สถานะ HTTP สาเหตุ แก้ไข
steps.keyvaluemapoperations.SetVariableFailed 500

ข้อผิดพลาดนี้เกิดขึ้นหากคุณพยายามเรียกค่าจากแมปค่าคีย์ที่เข้ารหัส แล้วตั้งค่าเป็นตัวแปรที่มีชื่อไม่ได้ขึ้นต้นด้วย private คำนำหน้าซึ่งจำเป็นสำหรับวัตถุประสงค์ด้านความปลอดภัยขั้นพื้นฐานระหว่างการแก้ไขข้อบกพร่อง จะซ่อนค่าที่เข้ารหัสจากการติดตามพร็อกซี API และเซสชันการแก้ไขข้อบกพร่อง

steps.keyvaluemapoperations.UnsupportedOperationException 500

ข้อผิดพลาดนี้เกิดขึ้นหากมีการตั้งค่าแอตทริบิวต์ mapIdentifier เป็นสตริงว่างเปล่าในนโยบายการดำเนินการแมปค่าคีย์

ข้อผิดพลาดในการทำให้ใช้งานได้

ข้อผิดพลาดเหล่านี้อาจเกิดขึ้นเมื่อคุณใช้พร็อกซีที่มีนโยบายนี้

ชื่อข้อผิดพลาด สาเหตุ แก้ไข
InvalidIndex หากแอตทริบิวต์ index ที่ระบุในองค์ประกอบ <Get> ของนโยบายการดำเนินการแมปค่าคีย์เป็น 0 หรือเป็นตัวเลขลบ จะทำให้การทำให้พร็อกซี API ใช้งานได้ไม่สำเร็จ ดัชนีจะเริ่มต้นจาก 1 ดังนั้นดัชนีที่เป็นจำนวนเต็ม 0 หรือจำนวนเต็มลบจึงถือว่าไม่ถูกต้อง
KeyIsMissing ข้อผิดพลาดนี้เกิดขึ้นหากองค์ประกอบ <Key> หายไปทั้งหมด หรือองค์ประกอบ <Parameter> หายไปภายในองค์ประกอบ <Key> ภายใต้องค์ประกอบ <Entry> ขององค์ประกอบ <InitialEntries> ของนโยบายการดำเนินการแมปค่าคีย์
ValueIsMissing ข้อผิดพลาดนี้เกิดขึ้นหากองค์ประกอบ <Value> หายไปใต้องค์ประกอบ <Entry> ขององค์ประกอบ <InitialEntries> ของนโยบายการดำเนินการแมปค่าคีย์

สคีมา

หมายเหตุการใช้งาน

ดูภาพรวมของแผนที่คีย์-ค่าได้ที่การทำงานกับแผนที่คีย์-ค่า

ที่เก็บแผนที่ค่าคีย์มีกลไกการคงอยู่แบบเบาสำหรับข้อมูลที่จัดรูปแบบเป็นคู่คีย์/ค่า คุณเข้าถึงข้อมูลเหล่านี้ได้ที่รันไทม์ผ่านนโยบายหรือโค้ด แผนที่มีข้อมูลใดๆ ในรูปแบบ key=value

เช่น localhost=127.0.0.1, zip_code=94110 หรือ first_name=felix ในตัวอย่างแรก localhost คือคีย์ และ 127.0.0.1 คือค่า ระบบจะจัดเก็บคู่คีย์/ค่าแต่ละคู่เป็นรายการในแผนที่คีย์ ค่า แผนที่ค่าคีย์จัดเก็บรายการได้หลายรายการ

ตัวอย่างการใช้แผนที่ค่าคีย์มีดังนี้ สมมติว่าคุณต้องการจัดเก็บรายการที่อยู่ IP ที่เชื่อมโยงกับสภาพแวดล้อม แบ็กเอนด์ต่างๆ คุณสามารถสร้างแผนที่คีย์-ค่าที่ชื่อ ipAddresses ซึ่งมีรายการคู่คีย์/ค่าเป็นรายการได้ เช่น JSON นี้สามารถแสดงแผนที่ดังกล่าวได้

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

คุณสามารถใช้โครงสร้างนี้เพื่อสร้างที่เก็บที่อยู่ IP ที่นโยบายใช้ได้ ในขณะรันไทม์เพื่อบังคับใช้การอนุญาตหรือการปฏิเสธรายการ IP เพื่อเลือกที่อยู่เป้าหมายของแบ็กเอนด์แบบไดนามิก และอื่นๆ โดยปกติแล้ว นโยบาย KeyValueMapOperations จะใช้เพื่อจัดเก็บหรือดึงข้อมูลที่มีอายุยาวนานซึ่งต้องนำกลับมาใช้ใหม่ในธุรกรรมคำขอ/คำตอบหลายรายการ

คุณสามารถจัดการแมปคีย์/ค่าผ่านนโยบาย KeyValueMapOperations หรือผ่าน Apigee Edge Management API ได้โดยตรง โปรดดูรายละเอียดเกี่ยวกับ API ของ Organization key/value maps API ในเอกสารอ้างอิง Management API คุณสามารถใช้ API เพื่ออัปโหลดชุดข้อมูลขนาดใหญ่ไปยังที่เก็บคีย์/ค่า หรือสร้างสคริปต์เพื่อจัดการรายการแมปคีย์/ค่า เป็นต้น คุณจะต้องสร้างแมปคีย์/ค่าด้วย API ก่อนที่จะเข้าถึงด้วยนโยบาย KeyValueMapOperations

การระบุและดึงข้อมูลชื่อคีย์

องค์ประกอบ <Parameter> และ <Value> ช่วยให้คุณ ระบุค่าลิเทอรัล (ค่าที่อยู่ระหว่างแท็กเปิดและปิด) หรือใช้แอตทริบิวต์ ref เพื่อระบุชื่อของตัวแปรที่มีค่าที่ควรใช้ใน รันไทม์

องค์ประกอบพารามิเตอร์ควรได้รับการกล่าวถึงเป็นพิเศษ เนื่องจากเป็นตัวกำหนดชื่อของคีย์ที่จะสร้างขึ้น รวมถึงชื่อคีย์ที่คุณต้องการดึงข้อมูลหรือลบ ต่อไปนี้เป็นตัวอย่าง 2 รายการ รายการแรกระบุชื่อคีย์ตามตัวอักษร และรายการที่ 2 ระบุชื่อคีย์โดยใช้ตัวแปร สมมติว่าใช้ข้อมูลต่อไปนี้เพื่อสร้างคีย์ใน KVM

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

ในอินสแตนซ์แรก ระบบจะจัดเก็บค่าลิเทอรัลของ "key_name_literal" ไว้ใน KVM เป็นชื่อคีย์ ในอินสแตนซ์ที่ 2 ค่าใดก็ตามที่อยู่ใน key.name.variable จะกลายเป็นชื่อของคีย์ใน KVM เช่น หาก key.name.variable มีค่า foo ระบบจะตั้งชื่อคีย์ว่า "foo"

เมื่อต้องการเรียกข้อมูลคีย์และค่าคีย์ด้วยการดำเนินการ GET (หรือลบด้วยการดำเนินการ DELETE) การตั้งค่า <Parameter> ต้องตรงกับชื่อคีย์ใน KVM ตัวอย่างเช่น หากชื่อคีย์ใน KVM คือ "foo" คุณจะระบุค่าลิเทอรัลด้วย <Parameter>foo</Parameter> หรือระบุตัวแปรที่มีค่า "foo" ที่ตรงกันได้ ดังนี้ <Parameter ref="variable.containing.foo"/>

หัวข้อที่เกี่ยวข้อง