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

אתם צופים במסמכי התיעוד של 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> מחרוזת מציין את מזהה המדיניות להרצה ברצף הפעולות הנוכחי.