הסבר על הגדרת תהליך

אתם צופים במסמכי התיעוד של Apigee Edge.
כדאי לעיין במסמכי התיעוד של Apigee X. מידע

בקטע הזה מופיע מידע עזר על רכיבי ה-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>
    <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 ו-PostClientFlow.

<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

בדוגמה הבאה אפשר לראות איך בודקים אם הערך של המאפיין 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>

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

סוג מחרוזת
רכיבי הורה <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> מחרוזת התג הזה מגדיר משפט מותנה שעובר עיבוד בזמן הריצה. אם הערך של ההצהרה הוא True, התהליך (וכל השלבים שלו) יבוצע. אם הביטוי מקבל את הערך 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 מבצע אחת מהמדיניות האלה על סמך הסיומת של נתיב כתובת ה-URL שהוא אוסף ממשתנה הזרימה proxy. אם הסיומת של נתיב כתובת ה-URL לא תואמת לאף אחד מהתנאים, 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> מסוג default:

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

יכול להיות רק <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> מחרוזת הגדרת משפט מותנה לשלב שמעובד בזמן הריצה. אם הערך של המשפט הוא true, ‏ Edge מבצע את השלב. אם הערך של ההצהרה הוא false, ‏ Edge מדלג על השלב.
<Name> מחרוזת מציינים את המזהה של המדיניות שרוצים להפעיל ברצף הפעולות הנוכחי.