הדף הזה רלוונטי ל-Apigee ול-Apigee Hybrid.
לעיון במסמכי התיעוד של
Apigee Edge
בקטע הזה מופיע מידע עזר על רכיבי ה-XML שמשמשים להגדרת תהליכי העבודה של proxy ל-API.
היררכיה ותחביר
בדוגמאות הבאות מוצגים ההיררכיה של הרכיבים והתחביר של רכיבי הגדרת התהליך:
היררכיית רכיבים
בדוגמה הבאה מוצגת ההיררכיה של רכיבי הגדרת התהליך בתוך הרכיבים <ProxyEndpoint> ו-<TargetEndpoint>:
<ProxyEndpoint | TargetEndpoint>
<PreFlow>
<Request>
<Step>
<Condition>
<Name>
<Response>
<Step>
<Condition>
<Name>
<Description>
<Flows>
<Flow>
<Description>
<Condition>
<Request>
<Step>
<Response>
<Step>
<Description>
<PostFlow>
<Request>
<Step>
<Response>
<Step>
<Description>
EventFlow
<Response>
<Step>
<Description>
<PostClientFlow> (<ProxyEndpoint> only)
<Response>
<Description>
// Additional configuration elements
</ProxyEndpoint | TargetEndpoint>תחביר
בדוגמה הבאה מוצג התחביר של רכיבי הגדרת התהליך. כל אחד מהרכיבים האלה מתואר בפירוט בקטעים הבאים:
<!-- ProxyEndpoint flow configuration file -->
<ProxyEndpoint ... >
...
<PreFlow name="flow_name">
<Description>flow_description</Description>
<Request>
<Step>
<Condition>property operator "value"</Condition>
<Name>policy_name</Name>
</Step>
...
</Request>
<Response>
<Step>
<Condition>property operator "value"</Condition>
<Name>policy_name</Name>
</Step>
...
</Response>
</PreFlow>
<Flows name="flow_name">
<Flow name="conditional_flow_name">
<Description>flow_description</Description>
<Condition>property operator "value"</Condition>
<Request>
<Step>
<Condition>property operator "value"</Condition>
<Name>policy_name</Name>
</Step>
...
</Request>
<Response>
<Step>
<Condition>property operator "value"</Condition>
<Name>policy_name</Name>
</Step>
...
</Response>
</Flow>
</Flows>
<PostFlow name="flow_name">
<Description>flow_description</Description>
<Request>
<Step>
<Condition>property operator "value"</Condition>
<Name>policy_name</Name>
</Step>
...
</Request>
<Response>
<Step>
<Condition>property operator "value"</Condition>
<Name>policy_name</Name>
</Step>
...
</Response>
</PostFlow>
<PostClientFlow name="flow_name">
<Description>flow_description</Description>
<Response>
<Step>
<Condition>property operator "value"</Condition>
<Name>policy_name</Name>
</Step>
...
</Response>
</PostClientFlow>
...
</ProxyEndpoint>
<!-- TargetEndpoint flow configuration file -->
<TargetEndpoint ... >
...
<PreFlow name="flow_name">
<Description>flow_description</Description>
<Request>
<Step>
<Condition>property operator "value"</Condition>
<Name>policy_name</Name>
</Step>
...
</Request>
<Response>
<Step>
<Condition>property operator "value"</Condition>
<Name>policy_name</Name>
</Step>
...
</Response>
</PreFlow>
<Flows name="flow_name">
<Flow name="conditional_flow_name">
<Description>flow_description</Description>
<Condition>property operator "value"</Condition>
<Request>
<Step>
<Condition>property operator "value"</Condition>
<Name>policy_name</Name>
</Step>
...
</Request>
<Response>
<Step>
<Condition>property operator "value"</Condition>
<Name>policy_name</Name>
</Step>
...
</Response>
</Flow>
...
</Flows>
<PostFlow name="flow_name">
<Description>flow_description</Description>
<Request>
<Step>
<Condition>property operator "value"</Condition>
<Name>policy_name</Name>
</Step>
...
</Request>
<Response>
<Step>
<Condition>property operator "value"</Condition>
<Name>policy_name</Name>
</Step>
...
</Response>
</PostFlow>
...
</TargetEndpoint>משתמשים באלמנטים האלה כדי להגדיר את הביצוע של PreFlow, Conditional Flow, PostFlow, EventFlow ו-PostClientFlow.
<Condition>
התג הזה מגדיר הצהרה שעוברת עיבוד בזמן הריצה. אם הערך של ההצהרה הוא true, השלב או התהליך שמשויכים לתנאי מבוצעים. אם הביטוי מקבל את הערך False, המערכת מתעלמת מהשלב או מהתהליך.
| סוג | String |
| רכיבי הורה |
<Flow><Step> |
| רכיבי צאצא | ללא |
אפשר להחיל תנאי על שלב ספציפי או על תהליך שלם, בהתאם למיקום של הרכיב: בתוך הרכיב <Flow> או בתוך הרכיב <Step>:
// Condition can apply to just one step: // Or to the flow:<Flows><Flows><Flow><Flow><Step><Condition><Condition><Step><Name><Name>... ... ... ... ... ... </Flows> </Flows>
אם תנאי בתוך <Step> מחזיר את הערך true, Apigee מבצע את השלב הזה. אם התנאי מקבל את הערך false, המערכת מדלגת על השלב.
אם תנאי בתוך <Flow> מחזיר את הערך true, Apigee מעבד את כל השלבים בתהליך. אם התנאי מקבל את הערך false, המערכת של Apigee מדלגת על כל התהליך.
תחביר
רכיב <Condition> משתמש בתחביר הבא:
<Condition>property operator "value"</Condition>
כאשר:
- property
- מאפיין משתנה של זרימת העבודה שרוצים להשתמש בו בתנאי. לדוגמה, למשתנה הזרימה
requestיש מאפיינים בשמותpathו-content. כדי להשתמש בהם בתנאי, מציינים את flow_variable[נקודה]property_name:request.path request.content
רשימה מלאה של משתני הזרימה והמאפיינים שלהם זמינה במאמר בנושא משתני זרימה.
- operator
- מבנה שמגדיר איך התנאי מחושב. דוגמאות לאופרטורים נפוצים:
> greater than <= less than or equal to < less than >= greater than or equal to = equals && and != not equals || or ~~ JavaRegex ~ Matches /~ MatchesPath
רשימה מלאה זמינה בקטע אופרטורים בחומר העזר בנושא תנאים.
- 'value'
- הערך שלפיו מתבצעת ההערכה של מאפיין משתנה הזרימה. בדרך כלל מדובר בסוג בסיסי כמו מספר שלם או מחרוזת. לדוגמה,
200או/cat. הערך יכול לכלול תווים כלליים, כמו כוכביות ותווים אחרים להתאמת תבניות, כפי שמתואר במאמר התאמת תבניות עם תנאים.
דוגמה 1
בדוגמה הבאה בודקים אם המאפיין verb
של משתנה הזרימה request הוא GET:
<!-- api-platform/reference/examples/flow-segments/condition-1.xml --> <ProxyEndpoint name="default"> <PreFlow name="my-preFlows"> <Description>My first PreFlow</Description> <Request> <Step> <Condition>request.verb = "GET"</Condition> <Name>Log-Request-OK</Name> </Step> </Request> </PreFlow> ... </ProxyEndpoint>
אם הבקשה היא GET, המדיניות Log-Request-OK מופעלת בדוגמה הזו.
דוגמה 2
בדוגמה הבאה בודקים את קוד התגובה:
<!-- api-platform/reference/examples/flow-segments/condition-2.xml --> <ProxyEndpoint name="default"> <PreFlow name="my-preFlows"> <Description>My first PreFlow</Description> <Response> <Step> <Condition>response.status.code LesserThanOrEquals 300</Condition> <Name>Log-Response-OK</Name> </Step> <Step> <Condition>response.status.code GreaterThan 300</Condition> <Name>Log-Response-NOT-OK</Name> </Step> </Response> </PreFlow> ... </ProxyEndpoint>
בהתאם לערך של הקוד, מופעלת מדיניות אחרת.
מאפיינים
לרכיב <Condition> אין מאפיינים.
רכיבי צאצא
לאלמנט <Condition> אין רכיבי צאצא.
<Description>
תיאור של התהליך במונחים שקריאים לאנשים. אפשר להשתמש באלמנט הזה כדי לספק מידע על התהליך לעצמכם או למפתחים אחרים. התיאור לא גלוי מחוץ לארגון.
| סוג | String |
| רכיבי הורה |
<Flow><PreFlow><PostFlow> |
| רכיבי צאצא | ללא |
תחביר
רכיב <Description> משתמש בתחביר הבא:
<Description>flow_description</Description>
דוגמה
בדוגמה הבאה מוצג רכיב <Description> שמציין את המטרה של זרימת נתונים:
<!-- api-platform/reference/examples/flow-segments/description-1.xml --> <ProxyEndpoint name="default"> <Flows name="my-conditional-flows"> <Flow name="reports"> <Request> <Description>Based on the path suffix, determine which flow to use</Description> <Step> <Condition>proxy.pathsuffix MatchesPath "/reports"</Condition> <Name>XML-to-JSON-1</Name> </Step> <Step> <Condition>proxy.pathsuffix MatchesPath "/forecasts"</Condition> <Name>XML-to-JSON-1</Name> </Step> </Request> </Flow> </Flows> ... </ProxyEndpoint>
מאפיינים
לרכיב <Description> אין מאפיינים.
רכיבי צאצא
לאלמנט <Description> אין רכיבי צאצא.
<Flow>
הגדרת קבוצה מותאמת אישית של שלבים ש-Apigee מבצע.
| סוג | אובייקט מורכב |
| רכיבי הורה |
<Flows> |
| רכיבי צאצא |
<Condition><Description><Request><Response> |
אפשר לציין <Condition> ב-<Flow>. במקרה כזה, Apigee מבצע את השלבים בתהליך רק אם התנאי מתקיים. אחרת, Apigee מדלג על כל התהליך.
רכיב <Flows> יכול להכיל כמה רכיבי <Flow>, שלכל אחד מהם יש תנאי ושלבים משלו. אם יש כמה רכיבי <Flow>, מערכת Apigee מפעילה רק את הראשון שבהם שלא מוגדר בו תנאי או שהתנאי שלו מתקיים (true).
אתם יכולים להגדיר תהליך ברירת מחדל שמופעל תמיד (אם אף אחד מהתהליכים המותנים האחרים לא מופעל). בהתאם להגדרות של ה-proxy ל-API, הוא יכול להיות כלי שימושי להגנה מפני התקפות זדוניות.
תחביר
רכיב <Flow> משתמש בתחביר הבא:
<Flow name="conditional_flow_name">
<Description>flow_description</Description>
<Condition>property operator "value"</Condition>
<Request>
<Step>
<Condition>property operator "value"</Condition>
<Name>policy_name</Name>
</Step>
...
</Request>
<Response>
<Step>
<Condition>property operator "value"</Condition>
<Name>policy_name</Name>
</Step>
...
</Response>
</Flow>כל רכיבי הצאצא של <Flow> הם אופציונליים.
דוגמה 1
בדוגמה הבאה מוצג <Flow> פשוט שתמיד מפעיל את המדיניות Log-Message-OK:
<!-- api-platform/reference/examples/flow-segments/flow-1.xml --> <ProxyEndpoint name="default"> <Flows name="my-flow"> <Flow> <Request> <Step> <Name>Log-Message-OK</Name> </Step> </Request> </Flow> </Flows> ... </ProxyEndpoint>
דוגמה 2
בדוגמה הבאה מוצג <Flow> עם כמה שלבים, שלכל אחד מהם יש תנאי משלו:
<!-- api-platform/reference/examples/flow-segments/flow-2.xml --> <ProxyEndpoint name="default"> <Flows name="my-conditional-flows"> <Flow name="reports"> <Request> <Description>Based on the path suffix, determine which flow to use</Description> <Step> <Condition>proxy.pathsuffix MatchesPath "/reports"</Condition> <Name>XML-to-JSON-1</Name> </Step> <Step> <Condition>proxy.pathsuffix MatchesPath "/forecasts"</Condition> <Name>Verify-Auth-1</Name> </Step> </Request> </Flow> </Flows> ... </ProxyEndpoint>
דוגמה 3
בדוגמה הבאה מוצגים כמה תהליכים בתהליך מותנה:
<!-- api-platform/reference/examples/flow-segments/flows-2.xml --> <ProxyEndpoint name="default"> <Flows> <Flow name="my-flow-1"> <Response> <Step> <Condition>response.status.code = 200</Condition> <Name>Assign-Message-1</Name> </Step> </Response> </Flow> <Flow name="my-flow-2"> <Response> <Step> <Condition>response.status.code >= 400</Condition> <Name>Assign-Message-2</Name> </Step> </Response> </Flow> <Flow name="my-flow-3"> <Response> <Step> <Condition>response.status.code >= 300</Condition> <Name>Assign-Message-3</Name> </Step> </Response> </Flow> </Flows> ... </ProxyEndpoint>
Apigee מפעיל רק רצף פעולות אחד בפלח. הוא מפעיל את רצף הפעולות הראשון שאין לו תנאי, או שהתנאי שלו הוא true.
מאפיינים
בטבלה הבאה מפורטים המאפיינים של הרכיב <Flow>:
| מאפיין | סוג | תיאור |
|---|---|---|
name |
String | (חובה) מזהה ייחודי של התהליך. לדוגמה,
My-Conditional-Flow-1. השם לא יכול להכיל רווחים או תווים מיוחדים אחרים. |
רכיבי צאצא
בטבלה הבאה מפורטים רכיבי המשנה של <Flow>:
| רכיב צאצא | סוג | תיאור |
|---|---|---|
<Condition> |
String | התג הזה מגדיר משפט מותנה שעובר עיבוד בזמן הריצה. אם הערך של ההצהרה הוא True, התהליך (וכל השלבים שלו) מבוצע. אם הביטוי מקבל את הערך False, המערכת מתעלמת מהזרימה (ומכל השלבים שלה). |
<Description> |
String | תיאור קצר של התהליך. התיאור הזה לא גלוי מחוץ לארגון. |
<Request> |
אובייקט מורכב | מצוינים השלבים והתנאים של פלח הבקשה. |
<Response> |
אובייקט מורכב | מציינים את השלבים והתנאים של פלח התגובה. |
<Flows>
מכיל אפס רכיבי <Flow> או יותר.
| סוג | אובייקט מורכב |
| רכיבי הורה |
<ProxyEndpoint><TargetEndpoint> |
| רכיבי צאצא |
<Flow> |
אם יש כמה רכיבי <Flow> בתוך <Flows>, רק רכיב <Flow> אחד יופעל. זה יהיה הרכיב הראשון שאין לו <Condition>, או שהתנאי שלו הוא true.
אתם יכולים להגדיר תהליך ברירת מחדל שמופעל תמיד (אם אף אחד מהתהליכים האחרים לא מופעל). בהתאם להגדרות של ה-proxy ל-API, הוא יכול להיות כלי שימושי להגנה מפני התקפות זדוניות.
תחביר
רכיב <Flows> משתמש בתחביר הבא:
<Flows name="flow_name">
<Flow name="conditional_flow_name">
<Description>flow_description</Description>
<Condition>property operator "value"</Condition>
<Request>
<Step>
<Condition>property operator "value"</Condition>
<Name>policy_name</Name>
</Step>
...
</Request>
<Response>
<Step>
<Condition>property operator "value"</Condition>
<Name>policy_name</Name>
</Step>
...
</Response>
</Flow>
</Flows>כל רכיבי הצאצא של <Flows> הם אופציונליים.
דוגמה 1
בדוגמה הבאה מוצג רכיב <Flows> פשוט עם <Flow> יחיד:
<!-- api-platform/reference/examples/flow-segments/flows-1.xml --> <ProxyEndpoint name="default"> <Flows name="my-conditional-flows"> <Flow name="reports"> <Request> <Description>Based on the path suffix, determine which flow to use</Description> <Step> <Condition>proxy.pathsuffix MatchesPath "/reports"</Condition> <Name>XML-to-JSON-1</Name> </Step> <Step> <Condition>proxy.pathsuffix MatchesPath "/forecasts"</Condition> <Name>Verify-Auth-1</Name> </Step> </Request> </Flow> </Flows> ... </ProxyEndpoint>
Apigee מפעיל אחת מהמדיניות האלה על סמך הסיומת של הנתיב שהוא אוסף ממשתנה הזרימה proxy. אם הסיומת של הנתיב לא תואמת לאף אחד מהתנאים, אז Apigee לא מפעיל את הזרימה הזו.
דוגמה 2
בדוגמה הבאה מוצגים כמה רכיבי <Flow> בתוך <Flows>, שלכל אחד מהם יש <Condition> משלו:
<!-- api-platform/reference/examples/flow-segments/flows-2.xml --> <ProxyEndpoint name="default"> <Flows> <Flow name="my-flow-1"> <Response> <Step> <Condition>response.status.code = 200</Condition> <Name>Assign-Message-1</Name> </Step> </Response> </Flow> <Flow name="my-flow-2"> <Response> <Step> <Condition>response.status.code >= 400</Condition> <Name>Assign-Message-2</Name> </Step> </Response> </Flow> <Flow name="my-flow-3"> <Response> <Step> <Condition>response.status.code >= 300</Condition> <Name>Assign-Message-3</Name> </Step> </Response> </Flow> </Flows> ... </ProxyEndpoint>
Apigee מריץ רק את התהליך הראשון בפלח שהתנאי שלו מחזיר את הערך true. אחרי כן, Apigee מדלג על שאר התהליכים בקטע.
דוגמה 3
בדוגמה הבאה מוצג <Flow> 'ברירת מחדל':
<!-- api-platform/reference/examples/flow-segments/flows-3.xml --> <ProxyEndpoint name="default"> <Flows> <Flow name="my-conditional-flow-1"> <Response> <Step> <Condition>response.status.code = 200</Condition> <Name>Assign-Message-1</Name> </Step> </Response> </Flow> <Flow name="my-conditional-flow-2"> <Response> <Step> <Condition>response.header.someheader = "42"</Condition> <Name>Assign-Message-2</Name> </Step> </Response> </Flow> <Flow name="my-default-flow"> <Response> <Step> <Name>Assign-Message-3</Name> </Step> </Response> </Flow> </Flows> ... </ProxyEndpoint>
Apigee מריץ רק את התהליך הראשון בפלח שהתנאי שלו מחזיר את הערך true. אם לא מופעלים תהליכים מותנים, מופעל התהליך השלישי בדוגמה הזו (ללא תנאי).
תהליך ברירת מחדל יכול להיות כלי שימושי בהגנה מפני התקפות זדוניות.
מאפיינים
לרכיב <Flows> אין מאפיינים.
רכיבי צאצא
הרכיב <Flows> כולל את רכיבי הצאצא הבאים:
| רכיב צאצא | סוג | תיאור |
|---|---|---|
<Flow> |
אובייקט מורכב | תהליך שמגדיר קבוצה אפשרית אחת של שלבים בתהליך מותנה. |
<Name>
המזהה של המדיניות להפעלה בתוך <Flow>.
| סוג | String |
| רכיבי הורה |
<Step> |
| רכיבי צאצא | ללא |
תחביר
רכיב <Name> משתמש בתחביר הבא:
<Name>policy_name</Name>
דוגמה
בדוגמה הבאה מוצגות שתי מדיניות שנוספו לתהליכים לפי השם שלהן:
<!-- api-platform/reference/examples/flow-segments/name-1.xml --> <ProxyEndpoint name="default"> <Flows name="my-conditional-flows"> <Flow name="reports"> <Request> <Description>Based on the path suffix, determine which flow to use</Description> <Step> <Condition>proxy.pathsuffix MatchesPath "/reports"</Condition> <Name>XML-to-JSON-1</Name> </Step> <Step> <Condition>proxy.pathsuffix MatchesPath "/forecasts"</Condition> <Name>Verify-Auth-1</Name> </Step> </Request> </Flow> </Flows> ... </ProxyEndpoint>
מאפיינים
לרכיב <Name> אין מאפיינים.
רכיבי צאצא
לאלמנט <Name> אין רכיבי צאצא.
<PostFlow>
הגדרת השלבים שיש לבצע ב-PostFlow של הבקשה והתגובה.
| סוג | אובייקט מורכב |
| רכיבי הורה |
<ProxyEndpoint><TargetEndpoint> |
| רכיבי צאצא |
<Description><Request><Response> |
רכיב <PostFlow> משתמש בתחביר הבא:
תחביר
<PostFlow name="flow_name">
<Description>flow_description</Description>
<Request>
<Step>
<Condition>property operator "value"</Condition>
<Name>policy_name</Name>
</Step>
...
</Request>
<Response>
<Step>
<Condition>property operator "value"</Condition>
<Name>policy_name</Name>
</Step>
...
</Response>
</PostFlow>דוגמה
בדוגמה הבאה מוצג PostFlow עם שלבים מוגדרים לבקשה ולתגובה:
<!-- api-platform/reference/examples/flow-segments/postflow-1.xml --> <ProxyEndpoint name="default"> <PostFlow name="my-postflows"> <Description>My first PostFlow</Description> <Request> <Step> <Condition>request.verb = "GET"</Condition> <Name>Log-Request-OK</Name> </Step> </Request> <Response> <Step> <Name>Set-Response-Headers</Name> </Step> </Response> </PostFlow> ... </ProxyEndpoint>
מאפיינים
בטבלה הבאה מפורטים המאפיינים של הרכיב <PostFlow>:
| מאפיין | סוג | תיאור |
|---|---|---|
name |
String | מזהה ייחודי של התהליך (ייחודי בנקודת הקצה). לדוגמה,
My-PostFlow-1. הערך לא יכול לכלול רווחים או תווים מיוחדים אחרים. |
רכיבי צאצא
בטבלה הבאה מפורטים רכיבי המשנה של <PostFlow>:
| רכיב צאצא | סוג | תיאור |
|---|---|---|
<Description> |
String | מספק תיאור קצר של התהליך. |
<Request> |
אובייקט מורכב | הגדרת המדיניות שתופעל במהלך PostFlow של הבקשה. |
<Response> |
אובייקט מורכב | הגדרת המדיניות שתופעל במהלך PostFlow של התשובה. |
<EventFlow>
המאפיין מגדיר את השלבים שצריך לבצע ב-EventFlow. נעשה שימוש ב-EventFlow כדי לתמוך באירועים שנשלחים מהשרת בסטרימינג. מידע נוסף זמין במאמר בנושא אירועים שנשלחים מהשרת בסטרימינג.
| סוג | אובייקט מורכב |
| רכיבי הורה |
<TargetEndpoint> |
| רכיבי צאצא |
<Description><Response> |
רכיב EventFlow משתמש בתחביר הבא:
תחביר
<EventFlow name="flow_name" content-type="text/event-stream">> <Description>flow_description</Description> <Response> <Step> <Name>policy_name</Name> </Step> </Response> </EventFlow>
דוגמה
בדוגמה הבאה מוצג EventFlow:
<TargetEndpoint name="default"> <EventFlow name="EF-1" content-type="text/event-stream"> <Response> <Step> <Name>Raise-Fault-Cred-Invalid</Name> <Condition>fault.name equals "invalid_access_token"</Condition> </Step> </Response> </EventFlow> <HTTPTargetConnection> </TargetEndpoint></pre>
מאפיינים
בטבלה הבאה מתוארים המאפיינים של רכיב EventFlow:
| מאפיין | סוג | תיאור |
|---|---|---|
name |
String | מזהה ייחודי של התהליך (ייחודי בנקודת הקצה). לדוגמה,
My-EventFlow-1. הערך לא יכול לכלול רווחים או תווים מיוחדים אחרים. |
content-type |
String | (חובה) הערך חייב להיות: content-type="text/event-stream" |
רכיבי צאצא
בטבלה הבאה מתוארים רכיבי המשנה של EventFlow:
| רכיב צאצא | סוג | תיאור |
|---|---|---|
<Description> |
String | מספק תיאור קצר של התהליך. |
<Response> |
אובייקט מורכב | הגדרת המדיניות שתופעל במהלך EventFlow של התגובה. |
<PostClientFlow>
מגדירה מדיניות ב-ProxyEndpoint שמופעלת רק אחרי שהתגובה מוחזרת ללקוח. בדרך כלל, ההודעות שקשורות לתגובה נרשמות ביומן של כללי המדיניות האלה.
| סוג | אובייקט מורכב |
| רכיבי הורה |
<ProxyEndpoint> |
| רכיבי צאצא |
<Description><Response> |
תחביר
רכיב <PostClientFlow> משתמש בתחביר הבא:
<PostClientFlow name="flow_name">
<Description>flow_description</Description>
<Response>
<Step>
<Condition>property operator "value"</Condition>
<Name>policy_name</Name>
</Step>
...
</Response>
</PostClientFlow>כל רכיבי הצאצא של <PostClientFlow> הם אופציונליים.
דוגמה
בדוגמה הבאה מוצג PostClientFlow פשוט שמבצע מדיניות אחת:
<!-- api-platform/reference/examples/flow-segments/postclientflow-1.xml --> <ProxyEndpoint name="default"> <PostClientFlow name="my-postclientflows"> <Description>My first PostClientFlow. Processed after the response is sent back to the client.</Description> <Response> <Step> <Name>Message-Logging-OK</Name> </Step> </Response> </PostClientFlow> ... </ProxyEndpoint>
מאפיינים
בטבלה הבאה מפורטים המאפיינים של הרכיב <PostClientFlow>:
| מאפיין | סוג | תיאור |
|---|---|---|
name |
String | מזהה ייחודי של התהליך. השם לא יכול לכלול רווחים או תווים מיוחדים אחרים. לדוגמה, My-PostClientFlow-1. |
רכיבי צאצא
בטבלה הבאה מפורטים רכיבי המשנה של <PostClientFlow>:
| רכיב צאצא | סוג | תיאור |
|---|---|---|
<Description> |
String | מספק תיאור קצר של התהליך. |
<Response> |
אובייקט מורכב | הגדרת המדיניות שתופעל במהלך PostFlow של התשובה. |
<PreFlow>
הגדרת המדיניות שתופעל ב-PreFlow של הבקשה והתגובה.
| סוג | אובייקט מורכב |
| רכיבי הורה |
<ProxyEndpoint><TargetEndpoint> |
| רכיבי צאצא |
<Description><Request><Response> |
תחביר
רכיב <PreFlow> משתמש בתחביר הבא:
<PreFlow name="flow_name">
<Description>flow_description</Description>
<Request>
<Step>
<Condition>property operator "value"</Condition>
<Name>policy_name</Name>
</Step>
...
</Request>
<Response>
<Step>
<Condition>property operator "value"</Condition>
<Name>policy_name</Name>
</Step>
...
</Response>
</PreFlow>כל רכיבי הצאצא של <PreFlow> הם אופציונליים.
דוגמה
בדוגמה הבאה מוצג PreFlow עם בקשה וזרימת תגובה מוגדרות:
<!-- api-platform/reference/examples/flow-segments/preflow-1.xml --> <ProxyEndpoint name="default"> <PreFlow name="my-preFlows"> <Description>My first PreFlow</Description> <Request> <Step> <Condition>request.verb = "GET"</Condition> <Name>Log-Request-OK</Name> </Step> </Request> <Response> <Step> <Condition>response.status.code LesserThanOrEquals 300</Condition> <Name>Log-Response-OK</Name> </Step> <Step> <Condition>response.status.code GreaterThan 300</Condition> <Name>Log-Response-NOT-OK</Name> </Step> </Response> </PreFlow> ... </ProxyEndpoint>
מאפיינים
בטבלה הבאה מפורטים המאפיינים של הרכיב <PreFlow>:
| מאפיין | סוג | תיאור |
|---|---|---|
name |
String | מזהה ייחודי של התהליך. השם לא יכול לכלול רווחים או תווים מיוחדים אחרים. לדוגמה, My-PreFlow-1. |
רכיבי צאצא
בטבלה הבאה מפורטים רכיבי המשנה של <PreFlow>:
| רכיב צאצא | סוג | תיאור |
|---|---|---|
<Description> |
String | מספק תיאור קצר של התהליך. |
<Request> |
אובייקט מורכב | הגדרת המדיניות שתופעל במהלך PreFlow של הבקשה. |
<Response> |
אובייקט מורכב | הגדרת המדיניות שתופעל במהלך PreFlow של התגובה. |
<Request>
הגדרת המדיניות שתופעל במהלך פלח הבקשה של התהליך.
| סוג | אובייקט מורכב |
| רכיבי הורה |
<Flow><PreFlow><PostFlow> |
| רכיבי צאצא |
<Step> |
תחביר
רכיב <Request> משתמש בתחביר הבא:
<Request>
<Step>
<Condition>property operator "value"</Condition>
<Name>policy_name</Name>
</Step>
...
</Request>כל רכיבי הצאצא של <Request> הם אופציונליים.
דוגמה
בדוגמה הבאה מוצגים תהליכי עבודה שמוגדרים לבקשה ב-PreFlow וב-PostFlow:
<!-- api-platform/reference/examples/flow-segments/request-1.xml --> <ProxyEndpoint name="default"> <PreFlow name="my-preFlows"> <Description>My first PreFlow</Description> <Request> <Step> <Condition>request.verb = "GET"</Condition> <Name>Log-Request-OK</Name> </Step> </Request> </PreFlow> <PostFlow name="my-postflows"> <Description>My first PostFlow</Description> <Request> <Step> <Condition>request.verb = "GET"</Condition> <Name>Log-Request-OK</Name> </Step> </Request> </PostFlow> ... </ProxyEndpoint>
מאפיינים
לרכיב <Request> אין מאפיינים.
רכיבי צאצא
בטבלה הבאה מפורטים רכיבי המשנה של <Request>:
| רכיב צאצא | סוג | תיאור |
|---|---|---|
<Step> |
String | מציינת מדיניות להפעלה בפלח הבקשה. יכול להיות שילד מהסוג הזה יופיע כמה פעמים. |
<Response>
המאפיין מגדיר את המדיניות שתופעל במהלך פלח התגובה של התהליך.
| סוג | אובייקט מורכב |
| רכיבי הורה |
<Flow><PreFlow><PostClientFlow><PostFlow> |
| רכיבי צאצא |
<Step> |
תחביר
רכיב <Response> משתמש בתחביר הבא:
<Response>
<Step>
<Condition>property operator "value"</Condition>
<Name>policy_name</Name>
</Step>
...
</Response>כל רכיבי הצאצא של <Response> הם אופציונליים.
דוגמה
בדוגמה הבאה מוצגים רכיבי Flow שהוגדרו לתגובה, גם ב-PreFlow וגם ב-PostFlow:
<!-- api-platform/reference/examples/flow-segments/response-1.xml --> <ProxyEndpoint name="default"> <PreFlow name="my-preFlows"> <Description>My first PreFlow</Description> <Response> <Step> <Condition>response.status.code LesserThanOrEquals 300</Condition> <Name>Log-Response-OK</Name> </Step> <Step> <Condition>response.status.code GreaterThan 300</Condition> <Name>Log-Response-NOT-OK</Name> </Step> </Response> </PreFlow> <PostFlow name="my-postflows"> <Description>My first PostFlow</Description> <Response> <Step> <Name>Set-Response-Headers</Name> </Step> </Response> </PostFlow> ... </ProxyEndpoint>
מאפיינים
לרכיב <Response> אין מאפיינים.
רכיבי צאצא
בטבלה הבאה מפורטים רכיבי המשנה של <Response>:
| רכיב צאצא | סוג | תיאור |
|---|---|---|
<Step> |
String | מציין מדיניות להפעלה בפלח התגובה. סוג הצאצא הזה יכול להופיע כמה פעמים. |
<Step>
מציין מדיניות להפעלה ותנאי (אופציונלי) שקובע אם להפעיל את המדיניות הזו.
| סוג | אובייקט מורכב |
| רכיבי הורה |
<Request><Response> |
| רכיבי צאצא |
<Condition><Name> |
אפשר להגדיר יותר משלב אחד ב-<Flow>, והשלבים מבוצעים בסדר שבו הם מוגדרים ב-XML של התהליך.
שלבים ללא תנאי תמיד מופעלים. שלבים עם תנאי מופעלים רק אם התנאי מחזיר את הערך true. אם התנאי מחזיר את הערך false, המערכת של Apigee מדלגת על השלב.
תחביר
רכיב <Step> משתמש בתחביר הבא:
<Step> <Condition>property operator "value"</Condition> <Name>policy_name</Name> </Step>
יכול להיות רק <Condition> אחד ורק <Name> אחד לכל <Step>, אבל יכולים להיות כמה שלבים ב-<Flow>.
כל רכיבי הצאצא של <Step> הם אופציונליים.
דוגמה 1
בדוגמה הבאה מוצג שלב אחד עם תנאי ושלב אחד בלי תנאי:
<!-- api-platform/reference/examples/flow-segments/step-1.xml --> <ProxyEndpoint name="default"> <PostFlow name="my-postflows"> <Description>My first PostFlow</Description> <Request> <Step> <Condition>request.verb = "GET"</Condition> <Name>Log-Request-OK</Name> </Step> </Request> <Response> <Step> <Name>Set-Response-Headers</Name> </Step> </Response> </PostFlow> ... </ProxyEndpoint>
השלב ללא התנאי יתבצע בכל פעם במהלך קטע הבקשה. השלב עם התנאי יתבצע רק אם הבקשה היא GET במהלך קטע התגובה.
דוגמה 2
בדוגמה הבאה מוצגים כמה שלבים בפלח אחד:
<!-- api-platform/reference/examples/flow-segments/step-2.xml --> <ProxyEndpoint name="default"> <PostFlow name="PostFlow"> <Response> <Step> <Name>Assign-Message-1</Name> </Step> <Step> <Name>Assign-Message-2</Name> </Step> </Response> </PostFlow> ... </ProxyEndpoint>
שלבים ללא תנאי תמיד מבוצעים.
מאפיינים
לרכיב <Step> אין מאפיינים.
רכיבי צאצא
בטבלה הבאה מפורטים רכיבי המשנה של <Step>:
| רכיב צאצא | סוג | תיאור |
|---|---|---|
<Condition> |
String | ההגדרה מגדירה משפט מותנה לשלב שעובר עיבוד בזמן הריצה. אם הערך של המשפט הוא true, Apigee מבצע את השלב. אם הערך של המשפט הוא false, Apigee מדלג על השלב. |
<Name> |
String | מציינים את המזהה של המדיניות שרוצים להפעיל בתהליך הנוכחי. |