การใช้ตัวแปรโฟลว์

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

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

วิดีโอ

วิดีโอต่อไปนี้เป็นข้อมูลเบื้องต้นเกี่ยวกับตัวแปรของ Funnel

ตัวแปรโฟลว์คืออะไร

ตัวแปรของโฟลว์จะอยู่ในบริบทของโฟลว์พร็อกซี API และติดตามสถานะในธุรกรรม API เช่นเดียวกับที่ตัวแปรที่มีชื่อติดตามสถานะในโปรแกรมซอฟต์แวร์ ตัวแปรของ FLow จะจัดเก็บข้อมูล เช่น

• ที่อยู่ IP, ส่วนหัว, เส้นทาง URL และเพย์โหลดที่ส่งมาจากแอปที่ส่งคำขอ
• ข้อมูลระบบ เช่น วันที่และเวลาที่ Edge ได้รับคำขอ
• ข้อมูลที่ได้จากการดำเนินการของนโยบาย ตัวอย่างเช่น หลังจากนโยบายที่ตรวจสอบโทเค็น OAuth ทำงาน Edge จะสร้างตัวแปรโฟลว์ที่มีข้อมูล เช่น ชื่อแอปพลิเคชันที่ส่งคำขอ
• ข้อมูลเกี่ยวกับการตอบกลับจากระบบเป้าหมาย

ตัวแปรบางรายการจะ "มีอยู่แล้ว" ใน Edge และระบบจะป้อนข้อมูลโดยอัตโนมัติทุกครั้งที่ได้รับคําขอ API ซึ่งจะพร้อมใช้งานตลอดการทำธุรกรรม API นอกจากนี้ คุณยังสร้างตัวแปรที่กําหนดเองของคุณเองได้โดยใช้นโยบาย เช่น นโยบาย AssignMessage หรือในโค้ด JavaScript, Node.js และ Java

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

ตัวแปรการไหลมีการใช้งานอย่างไร

ตัวแปรโฟลว์ใช้ในนโยบายและโฟลว์แบบมีเงื่อนไข ดังนี้

• นโยบายสามารถดึงข้อมูลสถานะจากตัวแปรของโฟลว์ และใช้สถานะดังกล่าวเพื่อทํางาน

  เช่น นโยบาย VerifyJWT สามารถดึงข้อมูลโทเค็นที่จะยืนยันจากตัวแปรการไหล แล้วทำการยืนยันโทเค็น อีกตัวอย่างหนึ่งคือ นโยบาย JavaScript เรียกตัวแปรโฟลว์และเข้ารหัสข้อมูลที่มีอยู่ภายในตัวแปรเหล่านั้นได้

• ขั้นตอนแบบมีเงื่อนไขจะอ้างอิงตัวแปรโฟลว์เพื่อกำหนดทิศทางของ API ผ่าน Edge ได้ คล้ายกับวิธีการทำงานของคำสั่งสวิตช์ในการเขียนโปรแกรม

  ตัวอย่างเช่น นโยบายที่จะแสดงผลข้อผิดพลาดอาจทํางานก็ต่อเมื่อมีการตั้งค่าตัวแปรโฟลว์หนึ่งๆ เท่านั้น สุดท้าย คุณสามารถรับและตั้งค่าตัวแปรการไหลในแอปพลิเคชันเป้าหมาย Node.js

เรามาดูตัวอย่างการใช้ตัวแปรในบริบทต่างๆ เหล่านี้กัน

ตัวแปรของโฟลว์ในนโยบาย

นโยบายบางรายการใช้ตัวแปรการไหลเป็นอินพุต

ตัวอย่างเช่น นโยบาย AssignMessage ต่อไปนี้จะนําค่าของตัวแปรโฟลว์ client.ip ไปใส่ในส่วนหัวของคําขอที่ชื่อ My-Client-IP หากเพิ่มลงในโฟลว์คำขอ นโยบายนี้จะตั้งค่าส่วนหัวที่ส่งไปยังเป้าหมายแบ็กเอนด์ หากตั้งค่าไว้ในขั้นตอนการตอบกลับ ระบบจะส่งส่วนหัวกลับไปยังแอปไคลเอ็นต์

<AssignMessage name="set-ip-in-header">
    <AssignTo createNew="false" transport="http" type="request">request</AssignTo>
    <Set>
        <Headers>
            <Header name="My-Client-IP">{client.ip}</Header>
        </Headers>
    </Set>
    <IgnoreUnresolvedVariables>true</IgnoreUnresolvedVariables>
</AssignMessage>

อีกตัวอย่างหนึ่งคือ เมื่อนโยบายโควต้าทำงาน ระบบจะป้อนข้อมูลตัวแปรการไหลหลายรายการด้วยค่าที่เกี่ยวข้องกับนโยบาย ตัวแปรอย่างใดอย่างหนึ่งเหล่านี้เรียกว่า ratelimit.my-quota-policy.used.count (โดยที่ my-quota-policy คือชื่อนโยบายโควต้าที่คุณสนใจ)

ในภายหลัง คุณอาจเรียกใช้โฟลว์แบบมีเงื่อนไขที่ระบุว่า "หากจำนวนโควต้าปัจจุบันต่ำกว่า 50% ของจำนวนสูงสุด และอยู่ในช่วง 9:00 น. - 17:00 น. ให้บังคับใช้โควต้าอื่น" เงื่อนไขนี้อาจขึ้นอยู่กับค่าของจำนวนโควต้าปัจจุบันและตัวแปรโฟลว์ชื่อ system.time ซึ่งเป็นตัวแปร Edge ในตัว

ตัวแปรของโฟลว์ในขั้นตอนแบบมีเงื่อนไข

โฟลว์แบบมีเงื่อนไข ประเมินตัวแปรโฟลว์และเปิดใช้พร็อกซีให้ทํางานแบบไดนามิก โดยทั่วไปจะใช้เงื่อนไขเพื่อเปลี่ยนลักษณะการทำงานของกฎขั้นตอน และกฎเส้นทาง

ต่อไปนี้คือโฟลว์แบบมีเงื่อนไขที่ประเมินค่าของตัวแปร request.verb ในขั้นตอนโฟลว์พร็อกซี ในกรณีนี้ หากคํากริยาของคําขอคือ POST ระบบจะเรียกใช้นโยบาย VerifyAPIKey รูปแบบนี้เป็นรูปแบบทั่วไปที่ใช้ในการกําหนดค่าพร็อกซี API

<PreFlow name="PreFlow">
    <Request>
        <Step>
            <Condition>request.verb equals "POST"</Condition>
            <Name>VerifyApiKey</Name>
        </Step>
    </Request>
</PreFlow>

ตอนนี้คุณอาจสงสัยว่าตัวแปรอย่าง request.verb, client.ip และ system.time มาจากไหน อินสแตนซ์และป้อนค่าเมื่อใด โปรดดูการทำความเข้าใจขอบเขตตัวแปรของโฟลว์เพื่อช่วยให้คุณเข้าใจว่าระบบจะสร้างตัวแปรเมื่อใดและตัวแปรจะพร้อมใช้งานเมื่อใด

ตัวแปร Flow ในโค้ด JavaScript ที่เรียกใช้ด้วยนโยบาย JavaScript

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

context.setVariable("response.header.X-Apigee-Target", context.getVariable("target.name"));

เทคนิคการใช้ JavaScript เพื่ออ่านและตั้งค่าตัวแปรนี้คล้ายกับงานที่คุณทำได้ด้วยนโยบาย AssignMessage (แสดงก่อนหน้านี้) การดำเนินการนี้เป็นเพียงอีกวิธีหนึ่งในการทำสิ่งต่างๆ ในลักษณะเดียวกันใน Edge สิ่งสำคัญที่ต้องจำคือ JavaScript ที่ดำเนินการโดยนโยบาย JavaScript จะมีสิทธิ์เข้าถึงตัวแปรโฟลว์ทั้งหมดที่มีอยู่และอยู่ในขอบเขตภายในโฟลว์พร็อกซี API

ตัวแปร Flow ในโค้ด Node.js

เมื่อใช้โมดูล apigee-access คุณจะตั้งค่าและเข้าถึงตัวแปรของโฟลว์ได้จากภายในโค้ด Node.js ที่ติดตั้งใช้งานใน Edge

ต่อไปนี้เป็นตัวอย่างง่ายๆ ที่ตัวแปรชื่อ custom.foo ได้รับการตั้งค่าเป็นค่า Bar เมื่อตั้งค่าแล้ว ตัวแปรใหม่นี้จะใช้กับนโยบายหรือโค้ดอื่นๆ ที่เกิดขึ้นในโฟลว์พร็อกซีหลังจากที่โค้ด Node.js ประมวลผล

var http = require('http');
var apigee = require('apigee-access');

http.createServer(function (request, response) {
  apigee.setVariable(request, "custom.foo", "Bar");
  response.writeHead(200, {'Content-Type': 'text/plain'});
  response.end('Hello World\n');
}).listen(8124);

console.log('Server running at http://127.0.0.1:8124/');

อ่านเพิ่มเติมเกี่ยวกับการใช้ apigee-access เพื่อทํางานกับตัวแปรได้ในการเข้าถึงตัวแปรของโฟลว์ใน Node.js

ทําความเข้าใจขอบเขตตัวแปรของโฟลว์

ขอบเขตตัวแปรเกี่ยวข้องกับโฟลว์หรือ "วงจร" โดยรวมของการเรียกพร็อกซี API

การจําลองขั้นตอนของพร็อกซี API

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

รูปภาพต่อไปนี้แสดงลําดับของขั้นตอนนี้ โปรดสังเกตว่าโฟลว์ประกอบด้วย 4 กลุ่มหลัก ได้แก่ ProxyEndpoint request, TargetEndpoint request, TargetEndpoint response และ ProxyEndpoint response

โปรดคำนึงถึงโครงสร้างโฟลว์นี้เมื่อเราเริ่มสำรวจตัวแปรโฟลว์ผ่านส่วนที่เหลือของหัวข้อนี้

ขอบเขตตัวแปรเกี่ยวข้องกับโฟลว์พร็อกซีอย่างไร

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

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

ตารางต่อไปนี้แสดงชุดขอบเขตตัวแปรทั้งหมดและระบุเวลาที่พร้อมใช้งานในโฟลว์พร็อกซี

ขอบเขตตัวแปร	ตําแหน่งที่จะป้อนข้อมูลตัวแปรเหล่านี้
คำขอพร็อกซี	กลุ่มคำขอ ProxyEndpoint
คำขอเป้าหมาย	กลุ่มคำขอ TargetEndpoint
คำตอบเป้าหมาย	กลุ่มการตอบกลับของ TargetEndpoint
การตอบกลับของพร็อกซี	กลุ่มการตอบกลับ ProxyEndpoint
พร้อมใช้งานเสมอ	ทันทีที่พร็อกซีได้รับคําขอ ตัวแปรเหล่านี้จะพร้อมใช้งานตลอดวงจรของโพร็อกซี

เช่น มีตัวแปร Edge ในตัวชื่อ client.ip ตัวแปรนี้มีขอบเขตเป็น "คำขอพร็อกซี" ระบบจะป้อนที่อยู่ IP ของไคลเอ็นต์ที่เรียกว่าพร็อกซีโดยอัตโนมัติ ระบบจะป้อนข้อมูลเมื่อคำขอเข้าถึง ProxyEndpoint เป็นครั้งแรกและใช้งานได้ตลอดวงจรการโฟลว์พร็อกซี

มีตัวแปรในตัวอีกตัวหนึ่งชื่อ target.url ขอบเขตของตัวแปรนี้คือ "คำขอเป้าหมาย" ซึ่งสร้างขึ้นในกลุ่มคำขอ TargetEndpoint ด้วย URL คำขอที่ส่งไปยังเป้าหมายแบ็กเอนด์ หากพยายามเข้าถึง target.url ในส่วนคําขอ ProxyEndpoint คุณจะได้รับค่า NULL หากคุณพยายามตั้งค่าตัวแปรนี้ก่อนที่จะอยู่ในขอบเขต พร็อกซีจะไม่ดำเนินการใดๆ โดยไม่สร้างข้อผิดพลาดและไม่ได้ตั้งค่าตัวแปร

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

<AssignMessage name="CopyRequestToResponse">
    <AssignTo type="response" createNew="false">response</AssignTo>
    <Copy source="request"/>
</AssignMessage>

นโยบายนี้เพียงคัดลอกออบเจ็กต์ request และกำหนดให้กับออบเจ็กต์ response แต่ควรวางนโยบายนี้ไว้ที่ใดในขั้นตอนการส่งผ่านข้อมูลผ่านพร็อกซี คำตอบคือต้องวางไว้ในคำตอบของ TargetEndpoint เนื่องจากขอบเขตของตัวแปรคำตอบคือ "คำตอบเป้าหมาย"

การอ้างอิงตัวแปรโฟลว์

ตัวแปรในตัวทั้งหมดใน Apigee Edge เป็นไปตามรูปแบบการตั้งชื่อแบบจุด กฎเกณฑ์นี้ช่วยให้ระบุวัตถุประสงค์ของตัวแปรได้ง่ายขึ้น เช่น system.time.hour และ request.content

Apigee สงวนคำนำหน้าต่างๆ เพื่อจัดระเบียบตัวแปรที่เกี่ยวข้องอย่างเหมาะสม โดยคำนำหน้าเหล่านี้ได้แก่

• request
• response
• system
• target

หากต้องการอ้างอิงตัวแปรในนโยบาย ให้ใส่ตัวแปรไว้ในวงเล็บปีกกา ตัวอย่างเช่น นโยบาย AssignMessage ต่อไปนี้จะนําค่าของตัวแปร client.ip มาใส่ในส่วนหัวของคําขอที่ชื่อ Client-IP

<AssignMessage name="set-ip-in-header">
    <AssignTo createNew="false" transport="http" type="request">request</AssignTo>
    <Set>
        <Headers>
            <Header name="Client-IP">{client.ip}</Header>
        </Headers>
    </Set>
    <IgnoreUnresolvedVariables>true</IgnoreUnresolvedVariables>
</AssignMessage>

ในโฟลว์แบบมีเงื่อนไข คุณไม่จำเป็นต้องใช้วงเล็บปีกกา เงื่อนไขตัวอย่างต่อไปนี้จะประเมินตัวแปร request.header.accept

<Step>
    <Condition>request.header.accept = "application/json"</Condition>
    <Name>XMLToJSON</Name>
</Step>

นอกจากนี้ คุณยังอ้างอิงตัวแปรการไหลในโค้ด JavaScript และ Java ได้ด้วย ดูข้อมูลเพิ่มเติมได้ที่

• การทํางานกับตัวแปรใน JavaScript
• การเข้าถึงตัวแปรการไหลใน Node.js
• นโยบาย JavaScript

ประเภทข้อมูลของตัวแปรการไหล

พร็อพเพอร์ตี้แต่ละรายการของตัวแปรการไหลมีประเภทข้อมูลที่กําหนดไว้อย่างชัดเจน เช่น สตริง, Long, Integer, บูลีน หรือคอลเล็กชัน คุณสามารถดูประเภทข้อมูลได้ที่ข้อมูลอ้างอิงตัวแปรของโฟลว์ สําหรับตัวแปรที่สร้างโดยนโยบาย ให้ดูข้อมูลประเภทข้อมูลในหัวข้อข้อมูลอ้างอิงนโยบายที่เฉพาะเจาะจง

ตัวแปรที่คุณสร้างด้วยตัวเองจะถือว่าเป็นประเภทที่กำหนดเมื่อสร้างขึ้น และจะขึ้นอยู่กับประเภทของค่าที่อนุญาต เช่น ตัวแปรที่สร้างในโค้ด Node.js จะจํากัดไว้ที่ตัวเลข สตริง บูลีน ว่าง หรือไม่มีการกำหนด

การใช้ตัวแปรโฟลว์ในนโยบาย

นโยบายจํานวนมากจะสร้างตัวแปรขั้นตอนเป็นส่วนหนึ่งของการดําเนินการตามปกติ ข้อมูลอ้างอิงนโยบายจะบันทึกตัวแปรเฉพาะนโยบายทั้งหมดเหล่านี้

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

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

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

ในตัวอย่างต่อไปนี้ ตัวแปรการแยกวิเคราะห์จะแยกวิเคราะห์ข้อความตอบกลับและจัดเก็บข้อมูลที่เจาะจงซึ่งดึงมาจากคำตอบ นโยบายจะสร้างตัวแปรที่กําหนดเอง 2 รายการ ได้แก่ geocoderesponse.latitude และ geocoderesponse.longitude และกำหนดค่าให้กับตัวแปรเหล่านั้น

<ExtractVariables name="ParseGeocodingResponse">
  <Source>response</Source>
  <VariablePrefix>geocoderesponse</VariablePrefix>
  <JSONPayload>
    <Variable name="latitude">
      <JSONPath>$.results[0].geometry.location.lat</JSONPath>
    </Variable>
    <Variable name="longitude">
      <JSONPath>$.results[0].geometry.location.lng</JSONPath>
    </Variable>
  </JSONPayload>
</ExtractVariables>

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

การใช้ตัวแปรการไหลในโค้ด JavaScript

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

หากต้องการเข้าถึงตัวแปรในโค้ด JavaScript ให้เรียกเมธอด getter/setter บนอ็อบเจกต์ต่อไปนี้

• context
• proxyRequest
• proxyResponse
• targetRequest
• targetResponse

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

ออบเจ็กต์ context สอดคล้องกับตัวแปรที่พร้อมใช้งาน "ทั่วโลก" เช่น ตัวแปรของระบบ ตัวอย่างเช่น คุณสามารถเรียกใช้ getVariable() ในออบเจ็กต์ context เพื่อรับปีปัจจุบันได้ดังนี้

var year = context.getVariable('system.time.year');

ในทํานองเดียวกัน คุณสามารถเรียกใช้ setVariable() เพื่อตั้งค่าตัวแปรที่กําหนดเองหรือตัวแปรที่เขียนได้ที่พร้อมใช้งาน ในส่วนนี้ เราจะสร้างตัวแปรที่กําหนดเองชื่อ organization.name.myorg และกำหนดค่าให้

var org = context.setVariable('organization.name.myorg', value);

เนื่องจากตัวแปรนี้สร้างขึ้นด้วยออบเจ็กต์ context จึงพร้อมใช้งานสำหรับกลุ่มขั้นตอนทั้งหมด (โดยพื้นฐานแล้ว การดำเนินการนี้เหมือนกับการสร้างตัวแปรส่วนกลาง)

นอกจากนี้ คุณยังรับ/ตั้งค่าตัวแปรโฟลว์พร็อกซีในโค้ด Java ที่เรียกใช้ด้วยนโยบาย JavaCallout ได้ด้วย

การเข้าถึงตัวแปรโฟลว์ในแอปพลิเคชัน Node.js

คุณสามารถรับ ตั้งค่า และลบตัวแปรของโฟลว์จากโค้ด Node.js ที่ติดตั้งใช้งานใน Edge สิ่งที่คุณต้องทำคือ "กำหนด" โมดูล apigee-access ในโค้ด โปรดดูรายละเอียดที่การเข้าถึงตัวแปรโฟลว์ใน Node.js

สิ่งที่ต้องจดจำ

สิ่งสำคัญที่ควรทราบเกี่ยวกับตัวแปรการไหลมีดังนี้

• พร็อกซีจะสร้างอินสแตนซ์และป้อนข้อมูลตัวแปร "พร้อมใช้งานทันที" บางรายการโดยอัตโนมัติ ข้อมูลเหล่านี้จะอยู่ในข้อมูลอ้างอิงตัวแปรเส้นทาง
• คุณสามารถสร้างตัวแปรที่กําหนดเองซึ่งพร้อมใช้งานในขั้นตอนการเปลี่ยนเส้นทางได้ คุณสามารถสร้างตัวแปรได้โดยใช้นโยบาย เช่น นโยบาย AssignMessage และนโยบาย JavaScript รวมถึงในโค้ด Node.js
• ตัวแปรมีขอบเขต ตัวอย่างเช่น ระบบจะป้อนข้อมูลตัวแปรบางรายการโดยอัตโนมัติเมื่อพร็อกซีแรกได้รับคําขอจากแอป ส่วนตัวแปรอื่นๆ จะป้อนข้อมูลในส่วนขั้นตอนการตอบกลับของพร็อกซี ตัวแปรการตอบกลับเหล่านี้จะยังคงไม่มีการกำหนดจนกว่ากลุ่มการตอบกลับจะดำเนินการ
• เมื่อนโยบายทำงาน นโยบายจะสร้างและป้อนข้อมูลตัวแปรเฉพาะนโยบายได้ เอกสารของแต่ละนโยบายจะแสดงรายการตัวแปรเฉพาะนโยบายที่เกี่ยวข้องทั้งหมดเหล่านี้
• โดยปกติแล้วขั้นตอนแบบมีเงื่อนไขจะประเมินตัวแปรอย่างน้อย 1 รายการ คุณต้องเข้าใจตัวแปรหากต้องการสร้างโฟลว์แบบมีเงื่อนไข
• นโยบายจํานวนมากใช้ตัวแปรเป็นอินพุตหรือเอาต์พุต ตัวอย่างเช่น ตัวแปรที่สร้างโดยนโยบายหนึ่งอาจถูกใช้โดยนโยบายอื่นในภายหลัง
• คุณสามารถรับและตั้งค่าตัวแปรการไหลหลายรายการจากภายใน Node.js โดยใช้ JavaScript โดยตรง (และโมเดลออบเจ็กต์ JavaScript) หรือนโยบาย JavaCallout ซึ่งจะเรียกใช้โค้ดใน Edge

ตัวอย่างโค้ดที่เกี่ยวข้อง

ตัวอย่างพร็อกซี API มีอยู่ใน GitHub และดาวน์โหลดและใช้งานได้ง่าย ดูข้อมูลเกี่ยวกับการดาวน์โหลดและการใช้ตัวอย่างได้ที่การใช้พร็อกซี API ตัวอย่าง ดูคำอธิบายตัวอย่างพร็อกซี API และหน้าที่ดำเนินการได้ที่รายการตัวอย่าง

ตัวอย่างพร็อกซีที่มีการใช้ตัวแปรและการประมวลผลตัวแปรมีดังนี้

• ตัวแปร - สาธิตวิธีดึงและตั้งค่าตัวแปรตามการส่งและเนื้อหาข้อความ JSON และ XML
• policy-mashup-cookbook - แอปพลิเคชันสมบูรณ์ที่ใช้องค์ประกอบของนโยบายเพื่อเรียกใช้ API สาธารณะ 2 รายการ รวมผลลัพธ์ และสร้างคำตอบที่สมบูรณ์ขึ้นสำหรับแอปไคลเอ็นต์ ดูข้อมูลเพิ่มเติมเกี่ยวกับตัวอย่างนี้ได้ที่การใช้องค์ประกอบนโยบาย
• conditional-policy - ใช้การบังคับใช้นโยบายแบบมีเงื่อนไขอย่างง่ายโดยอิงตามค่าตัวแปร

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

• ตัวแปรทั้งหมดที่ระบบป้อนข้อมูลในพร็อกซี API โดยอัตโนมัติจะแสดงอยู่ในข้อมูลอ้างอิงตัวแปรของโฟลว์ ข้อมูลอ้างอิงจะแสดงประเภทและขอบเขตของตัวแปรแต่ละรายการด้วย
• หากต้องการทราบว่านโยบายใดสร้างตัวแปรใด ให้ดูหัวข้ออ้างอิงสำหรับนโยบายนั้น เช่น ดูตัวแปรของโฟลว์ในข้อมูลอ้างอิงนโยบายโควต้า