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

כרגע מוצג התיעוד של Apigee Edge.
כניסה למסמכי התיעוד של Apigee X. מידע

בקטע הזה מופיע מידע על רכיבי ה-XML שבהם משתמשים כדי להגדיר את התהליכים של שרת ה-API של שרת ה-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, Conditionalflow, 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[dot]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.

ניתן להגדיר תהליך ברירת מחדל שיופעל תמיד (אם אף אחד מהתהליכים המותנים האחרים לא פועל). בהתאם לאופן שבו מוגדר שרת ה-API של שרת ה-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.

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

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