דף זה תורגם על ידי Cloud Translation API.

הפניה לתצורת זרימה

מוצג המסמך של Apigee Edge.
עוברים אל מסמכי תיעוד של Apigee X. מידע

החלק הזה מספק מידע על רכיבי ה-XML שבהם אתם משתמשים כדי להגדיר זרימות proxy ל-API.

מידע נוסף

היררכיה תחביר

הדוגמאות הבאות מציגות את היררכיית הרכיבים והתחביר של הגדרת הזרימה רכיבים:

היררכיית רכיבים

הדוגמה הבאה מציגה את ההיררכיה של רכיבי תצורת הזרימה בתוך רכיבי <ProxyEndpoint> ו-<TargetEndpoint>:

<ProxyEndpoint | TargetEndpoint>
    subdirectory_arrow_right<PreFlow>
          subdirectory_arrow_right<Request>
                subdirectory_arrow_right<Step>
                    subdirectory_arrow_right<Condition>
                    subdirectory_arrow_right<Name>
          subdirectory_arrow_right<Response>
                subdirectory_arrow_right<Step>
                    subdirectory_arrow_right<Condition>
                    subdirectory_arrow_right<Name>
          subdirectory_arrow_right<Description>
    subdirectory_arrow_right<Flows>
          subdirectory_arrow_right<Flow>
                subdirectory_arrow_right<Description>
                subdirectory_arrow_right<Condition>
                subdirectory_arrow_right<Request>
                      subdirectory_arrow_right<Step>
                          subdirectory_arrow_rightmore_horiz
                subdirectory_arrow_right<Response>
                      subdirectory_arrow_right<Step>
                          subdirectory_arrow_rightmore_horiz
          subdirectory_arrow_right<Description>
    subdirectory_arrow_right<PostFlow>
          subdirectory_arrow_right<Request>
                subdirectory_arrow_right<Step>
                    subdirectory_arrow_rightmore_horiz
          subdirectory_arrow_right<Response>
                subdirectory_arrow_right<Step>
                    subdirectory_arrow_rightmore_horiz
          subdirectory_arrow_right<Description>
    subdirectory_arrow_right<PostClientFlow> (<ProxyEndpoint> only)
          subdirectory_arrow_right<Response>
                subdirectory_arrow_rightmore_horiz
          subdirectory_arrow_right<Description>

    more_horiz  // 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 ו-PostClientFlow להגדיר.

רכיבי תצורה אחרים

הקטע הזה לא כולל את הרכיבים הבאים שמשמשים להגדרה של שרת proxy:

<APIProxy>
<DefaultFaultRule>
<FaultRules>
<HTTPProxyConnection>
<ProxyEndpoint>
<RouteRule>
<TargetEndpoint>

ברכיבים האלה, שמגדירים את התצורה של proxy ולא את הזרימה, בחומר העזר בנושא הגדרות של שרת Proxy ל-API.

`<Condition>`

מגדיר הצהרה שמעובדת בזמן ריצה. אם ההצהרה היא True, השלב או התהליך שמשויכים לתנאי מתבצע. אם הערך של ההצהרה מקבל את הערך False, והמערכת מתעלמת מהשלב או מהתהליך.

סוג	מחרוזת
רכיבי הורה	`<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, דפדפן Edge יבצע את השלב הזה. אם התנאי הפונקציה מחזירה את הערך False, דפדפן Edge מדלג על השלב.

אם תנאי בתוך <Flow> מקבל את הערך True, דפדפן Edge מעבד את כל השלבים בתהליך. אם המיקום אם התנאי מקבל את הערך False, Edge מדלג על כל התהליך.

תחביר

הרכיב <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

בדוגמה הבאה בודקים אם משתנה הזרימה request הוא verb הוא "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>`

מתאר את התהליך במונחים קריאים לאנשים. אתם יכולים להשתמש ברכיב הזה כדי לספק מידע על אל עצמכם או אל מפתחים אחרים. התיאור לא גלוי לגורמים חיצוניים.

סוג	מחרוזת
רכיבי הורה	`<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>`

מגדירה קבוצה מותאמת אישית של שלבים ש-Edge מבצע.

סוג	אובייקט מורכב
רכיבי הורה	`<Flows>`
רכיבי צאצא	`<Condition>` `<Description>` `<Request>` `<Response>`

אפשר לציין <Condition> ב-<Flow>. במקרה כזה, דפדפן Edge מפעיל רק השלבים בתהליך אם התנאי מקבל את הערך True. אחרת, Edge מדלג על כל הטקסט .

רכיב <Flows> יכול להכיל מספר רכיבי <Flow>, ולכל אחד מהם תנאי משלו ושלבים. כשיש מספר רכיבי <Flow>, Edge מפעיל רק את הרכיב הראשון שבו אין תנאי או שהתנאי מקבל את הערך 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>

Edge מבצע רק תהליך אחד בקטע. הוא מבצע את התהליך הראשון שלא תנאי, או שהתנאי שלו צריך להיות True.

מאפיינים

בטבלה הבאה מתוארים המאפיינים של הרכיב <Flow>:

מאפיין	סוג	תיאור
`name`	מחרוזת	(חובה) מזהה ייחודי לתהליך. לדוגמה, "My-Conditional-Flow-1". השם לא יכול להכיל רווחים או תווים מיוחדים אחרים.

רכיבי צאצא

בטבלה הבאה מתוארים רכיבי הצאצא של <Flow>:

רכיב צאצא	סוג	תיאור
`<Condition>`	מחרוזת	מגדירה הצהרה מותנית שמעובדת בזמן ריצה. אם ההצהרה היא אמת, אז הזרימה (וכל השלבים שלה) מתבצעת. אם ההצהרה היא False, המערכת מתעלמת מהתהליך (ומכל השלבים שלו).
`<Description>`	מחרוזת	תיאור קצר של התהליך. התיאור הזה לא קיים במיקום חיצוני גלוי.
`<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>

דפדפן Edge מפעיל את אחד מכללי המדיניות האלה על סמך סיומת הנתיב שהוא אוסף משתנה זרימה proxy. אם סיומת הנתיב לא תואמת לאף אחד מהתנאים, אז אפליקציית Edge לא מבצעת את התהליך הזה.

דוגמה 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>

Edge מבצע רק את הזרימה הראשונה בקטע שהתנאי שלו מקבל את הערך True. אחרי ש-Edge מדלג על התהליכים הנותרים בקטע.

דוגמה 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>

Edge מבצע רק את הזרימה הראשונה בקטע שהתנאי שלו מקבל את הערך True. אם המיקום לא מתבצע תהליכים מותנים, ולאחר מכן התהליך השלישי בדוגמה הזו (ללא תנאי) מבצע.

תהליך ברירת מחדל יכול להיות כלי שימושי הגנה מפני תוכנות זדוניות מתקפות.

מאפיינים

לרכיב <Flows> אין מאפיינים.

רכיבי צאצא

הרכיב <Flows> כולל את רכיבי הצאצא הבאים:

רכיב צאצא	סוג	תיאור
`<Flow>`	אובייקט מורכב	זרימה שמגדירה קבוצה אפשרית אחת של שלבים בתהליך המותנה.

`<Name>`

מציין את מזהה המדיניות שתתבצע בתוך <Flow>.

סוג	מחרוזת
רכיבי הורה	`<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`	מחרוזת	מזהה ייחודי של התהליך (ייחודי בנקודת הקצה). לדוגמה, "My-PostFlow-1". הערך לא יכול לכלול רווחים או תווים מיוחדים אחרים.

רכיבי צאצא

בטבלה הבאה מתוארים רכיבי הצאצא של <PostFlow>:

רכיב צאצא	סוג	תיאור
`<Description>`	מחרוזת	תיאור קצר של התהליך.
`<Request>`	אובייקט מורכב	הגדרת המדיניות להפעלה במהלך PostFlow של הבקשה.
`<Response>`	אובייקט מורכב	הגדרת המדיניות להפעלה במהלך PostFlow של התשובה.

`<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`	מחרוזת	מזהה ייחודי לזרימה. השם לא יכול לכלול רווחים או תווים מיוחדים אחרים תווים. לדוגמה, "My-PostClientFlow-1".

רכיבי צאצא

בטבלה הבאה מתוארים רכיבי הצאצא של <PostClientFlow>:

רכיב צאצא	סוג	תיאור
`<Description>`	מחרוזת	תיאור קצר של התהליך.
`<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`	מחרוזת	מזהה ייחודי לזרימה. השם לא יכול לכלול רווחים או תווים מיוחדים אחרים תווים. לדוגמה, "My-PreFlow-1".

רכיבי צאצא

בטבלה הבאה מתוארים רכיבי הצאצא של <PreFlow>:

רכיב צאצא	סוג	תיאור
`<Description>`	מחרוזת	תיאור קצר של התהליך.
`<Request>`	אובייקט מורכב	הגדרת המדיניות שצריך לבצע במהלך ה-PreFlow של הבקשה.
`<Response>`	אובייקט מורכב	הגדרת כללי המדיניות שיופעלו במהלך ה-PreFlow של התשובה.

`<Request>`

הגדרת המדיניות שצריך לבצע במהלך קטע הבקשה בתהליך.

סוג	אובייקט מורכב
רכיבי הורה	`<Flow>` `<PreFlow>` `<PostFlow>`
רכיבי צאצא	`<Condition>` `<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>:

רכיב צאצא	סוג	תיאור
`<Condition>`	אובייקט מורכב	המדיניות קובעת אם השלבים בתוך קטע הבקשה יבוצעו.
`<Step>`	מחרוזת	מציינת מדיניות להפעלה בתוך קטע הבקשה.

`<Response>`

הגדרת המדיניות שצריך לבצע במהלך קטע התגובה בתהליך.

סוג	אובייקט מורכב
רכיבי הורה	`<Flow>` `<PreFlow>` `<PostClientFlow>` `<PostFlow>`
רכיבי צאצא	`<Condition>` `<Step>`

תחביר

הרכיב <Response> משתמש בתחביר הבא:

<Response>
  <Step>
    <Condition>property operator "value"</Condition>
    <Name>policy_name</Name>
  </Step>
  ...
</Response>

כל רכיבי הצאצא של <Response> הם אופציונליים.

דוגמה

בדוגמה הבאה מוצגים תהליכים שהוגדרו לתגובה, גם ב-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>:

רכיב צאצא	סוג	תיאור
`<Condition>`	מחרוזת	המדיניות קובעת אם השלבים בתוך קטע התגובה יבוצעו.
`<Step>`	מחרוזת	מציינת מדיניות להפעלה בתוך קטע התגובה.

`<Step>`

מציינת מדיניות להפעלה, ו (אופציונלי) גם תנאי שקובע אם להפעיל המדיניות הזו.

סוג	אובייקט מורכב
רכיבי הורה	`<Request>` `<Response>`
רכיבי צאצא	`<Condition>` `<Name>`

אפשר להגדיר יותר משלב אחד ב<Flow>, והשלבים מתבצעים הסדר שבו הם מוגדרים ב-XML של הזרימה.

שלבים ללא תנאי מופעלים תמיד. שלבים עם תנאי מבוצעים רק אם התנאי הפונקציה מחזירה את הערך True. אם התנאי מקבל את הערך False, Edge מדלג על השלב.

תחביר

הרכיב <Step> משתמש בתחביר הבא:

<Step>
  <Condition>property operator "value"</Condition>
  <Name>policy_name</Name>
</Step>

לכל <Step> יכול להיות רק <Condition> אחד ו<Name> אחד, אבל יכולים להיות כמה שלבים ב<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>`	מחרוזת	מגדירה הצהרה מותנית לשלב שמעובד בזמן ריצה. אם שהערך של ההצהרה שלו הוא True, ואז Edge מבצע את השלב. אם ההצהרה היא false, ו-Edge מדלג על השלב.
`<Name>`	מחרוזת	מציין את מזהה המדיניות שתבוצע בתהליך הנוכחי.