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

הדף הזה רלוונטי ל-Apigee ול-Apigee Hybrid.

לעיון במסמכי התיעוד של Apigee Edge

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

מידע נוסף

• שליטה בהרצת פרוקסי באמצעות זרימות
• API Proxy Configuration Reference

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

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

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

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

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

      // Additional configuration elements

</ProxyEndpoint | TargetEndpoint>

תחביר

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

<!-- ProxyEndpoint flow configuration file -->
<ProxyEndpoint ... >
  ...
  <PreFlow name="flow_name">
    <Description>flow_description</Description>
    <Request>
      <Step>
        <Condition>property operator "value"</Condition>
        <Name>policy_name</Name>
      </Step>
      ...
    </Request>
    <Response>
      <Step>
        <Condition>property operator "value"</Condition>
        <Name>policy_name</Name>
      </Step>
      ...
    </Response>
  </PreFlow>
  <Flows name="flow_name">
    <Flow name="conditional_flow_name">
      <Description>flow_description</Description>
      <Condition>property operator "value"</Condition>
      <Request>
        <Step>
          <Condition>property operator "value"</Condition>
          <Name>policy_name</Name>
        </Step>
        ...
      </Request>
      <Response>
        <Step>
          <Condition>property operator "value"</Condition>
          <Name>policy_name</Name>
        </Step>
        ...
      </Response>
    </Flow>
  </Flows>
  <PostFlow name="flow_name">
    <Description>flow_description</Description>
    <Request>
      <Step>
        <Condition>property operator "value"</Condition>
        <Name>policy_name</Name>
      </Step>
      ...
    </Request>
    <Response>
      <Step>
        <Condition>property operator "value"</Condition>
        <Name>policy_name</Name>
      </Step>
      ...
    </Response>
  </PostFlow>
  <PostClientFlow name="flow_name">
    <Description>flow_description</Description>
    <Response>
      <Step>
        <Condition>property operator "value"</Condition>
        <Name>policy_name</Name>
      </Step>
      ...
    </Response>
  </PostClientFlow>
  ...
</ProxyEndpoint>

<!-- TargetEndpoint flow configuration file -->
<TargetEndpoint ... >
  ...
  <PreFlow name="flow_name">
    <Description>flow_description</Description>
    <Request>
      <Step>
        <Condition>property operator "value"</Condition>
        <Name>policy_name</Name>
      </Step>
      ...
    </Request>
    <Response>
      <Step>
        <Condition>property operator "value"</Condition>
        <Name>policy_name</Name>
      </Step>
      ...
    </Response>
  </PreFlow>
  <Flows name="flow_name">
    <Flow name="conditional_flow_name">
      <Description>flow_description</Description>
      <Condition>property operator "value"</Condition>
      <Request>
        <Step>
          <Condition>property operator "value"</Condition>
          <Name>policy_name</Name>
        </Step>
        ...
      </Request>
      <Response>
        <Step>
          <Condition>property operator "value"</Condition>
          <Name>policy_name</Name>
        </Step>
        ...
      </Response>
    </Flow>
    ...
  </Flows>
  <PostFlow name="flow_name">
    <Description>flow_description</Description>
    <Request>
      <Step>
        <Condition>property operator "value"</Condition>
        <Name>policy_name</Name>
      </Step>
      ...
    </Request>
    <Response>
      <Step>
        <Condition>property operator "value"</Condition>
        <Name>policy_name</Name>
      </Step>
      ...
    </Response>
  </PostFlow>
  ...
</TargetEndpoint>

משתמשים באלמנטים האלה כדי להגדיר את הביצוע של PreFlow,‏ Conditional Flow,‏ PostFlow,‏ EventFlow ו-PostClientFlow.

רכיבי הגדרה אחרים

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

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

האלמנטים האלה מגדירים את ההגדרות של שרת ה-proxy ולא את התהליכים. מידע נוסף זמין במאמר הפניית הגדרות של שרת proxy ל-API.

<Condition>

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

סוג	String
רכיבי הורה	<Flow> <Step>
רכיבי צאצא	ללא

אפשר להחיל תנאי על שלב ספציפי או על תהליך שלם, בהתאם למיקום של הרכיב: בתוך הרכיב <Flow> או בתוך הרכיב <Step>:

// Condition can apply to just one step:        // Or to the flow:
<Flows>                                         <Flows>
  <Flow>                                          <Flow>
    <Step>                                          <Condition>
      <Condition>                                   <Step>
      <Name>                                          <Name>
      ...                                             ...
    ...                                             ...
  ...                                             ...
</Flows>                                        </Flows>

אם תנאי בתוך <Step> מחזיר את הערך true, המערכת מבצעת את השלב הזה. אם התנאי מקבל את הערך false, המערכת של Apigee מדלגת על השלב.

אם תנאי בתוך <Flow> מחזיר את הערך true, המערכת של Apigee מעבדת את כל השלבים בתהליך. אם התנאי מקבל את הערך false, המערכת מדלגת על כל התהליך.

תחביר

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

<Condition>property operator "value"</Condition>

כאשר:

property

מאפיין משתנה הזרימה שרוצים להשתמש בו בתנאי. לדוגמה, למשתנה הזרימה request יש מאפיינים בשמות path ו-content. כדי להשתמש בהם בתנאי, מציינים את flow_variable[נקודה]property_name:

request.path
request.content

רשימה מלאה של משתני הזרימה והמאפיינים שלהם מופיעה במאמר בנושא משתני זרימה.

operator

מבנה שמגדיר איך התנאי מחושב. דוגמאות לאופרטורים נפוצים:

>     greater than           <=    less than or equal to
<     less than              >=    greater than or equal to
=     equals                 &&    and
!=    not equals             ||    or

~~    JavaRegex
~     Matches
/~    MatchesPath

רשימה מלאה זמינה במאמר אופרטורים בחומר העזר בנושא תנאים.

'value'

הערך שלפיו מוערך המאפיין של משתנה הזרימה. בדרך כלל זהו סוג בסיסי כמו מספר שלם או מחרוזת. לדוגמה, 200 או /cat. הערך יכול לכלול תווים כלליים, כמו כוכביות ותווים אחרים להתאמת תבניות, כפי שמתואר במאמר התאמת תבניות עם תנאים.

דוגמה 1

בדוגמה הבאה נבדק אם המאפיין verb של משתנה הזרימה request הוא GET:

<!-- api-platform/reference/examples/flow-segments/condition-1.xml -->
<ProxyEndpoint name="default">
  <PreFlow name="my-preFlows">
    <Description>My first PreFlow</Description>
    <Request>
      <Step>
        <Condition>request.verb = "GET"</Condition>
        <Name>Log-Request-OK</Name>
      </Step>
    </Request>
  </PreFlow>
  ...
</ProxyEndpoint>

אם הבקשה היא GET, הדוגמה הזו מפעילה את מדיניות Log-Request-OK.

דוגמה 2

בדוגמה הבאה בודקים את קוד התגובה:

<!-- api-platform/reference/examples/flow-segments/condition-2.xml -->
<ProxyEndpoint name="default">
  <PreFlow name="my-preFlows">
    <Description>My first PreFlow</Description>
    <Response>
      <Step>
        <Condition>response.status.code LesserThanOrEquals 300</Condition>
        <Name>Log-Response-OK</Name>
      </Step>
      <Step>
        <Condition>response.status.code GreaterThan 300</Condition>
        <Name>Log-Response-NOT-OK</Name>
      </Step>
    </Response>
  </PreFlow>
  ...
</ProxyEndpoint>

בהתאם לערך של הקוד, מופעלת מדיניות אחרת.

מאפיינים

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

רכיבי צאצא

לאלמנט <Condition> אין רכיבי צאצא.

<Description>

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

סוג	String
רכיבי הורה	<Flow> <PreFlow> <PostFlow>
רכיבי צאצא	ללא

תחביר

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

<Description>flow_description</Description>

דוגמה

בדוגמה הבאה מוצג רכיב <Description> שמציין את המטרה של זרימת נתונים:

<!-- api-platform/reference/examples/flow-segments/description-1.xml -->
<ProxyEndpoint name="default">
  <Flows name="my-conditional-flows">
    <Flow name="reports">
      <Request>
        <Description>Based on the path suffix, determine which flow to use</Description>
        <Step>
          <Condition>proxy.pathsuffix MatchesPath "/reports"</Condition>
          <Name>XML-to-JSON-1</Name>
        </Step>
        <Step>
          <Condition>proxy.pathsuffix MatchesPath "/forecasts"</Condition>
          <Name>XML-to-JSON-1</Name>
        </Step>
      </Request>
    </Flow>
  </Flows>
  ...
</ProxyEndpoint>

מאפיינים

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

רכיבי צאצא

לאלמנט <Description> אין רכיבי צאצא.

<Flow>

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

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

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

רכיב <Flows> יכול להכיל כמה רכיבי <Flow>, כל אחד עם תנאי ושלבים משלו. אם יש כמה רכיבי <Flow>, ‏ Apigee מפעיל רק את הראשון שבו לא מוגדר תנאי או שהתנאי מוגדר כ-true.

אתם יכולים להגדיר תהליך ברירת מחדל שמופעל תמיד (אם אף אחד מהתהליכים המותנים האחרים לא מופעל). בהתאם להגדרות של ה-proxy ל-API, הוא יכול להיות כלי שימושי להגנה מפני מתקפות זדוניות.

תחביר

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

<Flow name="conditional_flow_name">
  <Description>flow_description</Description>
  <Condition>property operator "value"</Condition>
  <Request>
    <Step>
      <Condition>property operator "value"</Condition>
      <Name>policy_name</Name>
    </Step>
    ...
  </Request>
  <Response>
    <Step>
      <Condition>property operator "value"</Condition>
      <Name>policy_name</Name>
    </Step>
    ...
  </Response>
</Flow>

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

דוגמה 1

בדוגמה הבאה מוצג <Flow> פשוט שתמיד מפעיל את המדיניות Log-Message-OK:

<!-- api-platform/reference/examples/flow-segments/flow-1.xml -->
<ProxyEndpoint name="default">
  <Flows name="my-flow">
    <Flow>
      <Request>
        <Step>
          <Name>Log-Message-OK</Name>
        </Step>
      </Request>
    </Flow>
  </Flows>
  ...
</ProxyEndpoint>

דוגמה 2

בדוגמה הבאה מוצג <Flow> עם כמה שלבים, שלכל אחד מהם יש תנאי משלו:

<!-- api-platform/reference/examples/flow-segments/flow-2.xml -->
<ProxyEndpoint name="default">
  <Flows name="my-conditional-flows">
    <Flow name="reports">
      <Request>
        <Description>Based on the path suffix, determine which flow to use</Description>
        <Step>
          <Condition>proxy.pathsuffix MatchesPath "/reports"</Condition>
          <Name>XML-to-JSON-1</Name>
        </Step>
        <Step>
          <Condition>proxy.pathsuffix MatchesPath "/forecasts"</Condition>
          <Name>Verify-Auth-1</Name>
        </Step>
      </Request>
    </Flow>
  </Flows>
  ...
</ProxyEndpoint>

דוגמה 3

בדוגמה הבאה מוצגים כמה תהליכים בתהליך מותנה:

<!-- api-platform/reference/examples/flow-segments/flows-2.xml -->
<ProxyEndpoint name="default">
  <Flows>
    <Flow name="my-flow-1">
      <Response>
        <Step>
          <Condition>response.status.code = 200</Condition>
          <Name>Assign-Message-1</Name>
        </Step>
      </Response>
    </Flow>
    <Flow name="my-flow-2">
      <Response>
        <Step>
          <Condition>response.status.code >= 400</Condition>
          <Name>Assign-Message-2</Name>
        </Step>
      </Response>
    </Flow>
    <Flow name="my-flow-3">
      <Response>
        <Step>
          <Condition>response.status.code >= 300</Condition>
          <Name>Assign-Message-3</Name>
        </Step>
      </Response>
    </Flow>
  </Flows>
  ...
</ProxyEndpoint>

‫Apigee מפעיל רק רצף פעולות אחד בפלח. הוא מפעיל את רצף הפעולות הראשון שאין לו תנאי, או שהתנאי שלו הוא true.

מאפיינים

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

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

רכיבי צאצא

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

רכיב צאצא	סוג	תיאור
<Condition>	String	התג הזה מגדיר משפט מותנה שעובר עיבוד בזמן הריצה. אם הערך של הביטוי הוא True, התהליך (וכל השלבים שלו) יופעל. אם הערך של הביטוי הוא false, המערכת מתעלמת מהזרימה (ומכל השלבים שלה).
<Description>	String	מספק תיאור קצר של התהליך. התיאור הזה לא גלוי מחוץ ל-
<Request>	אובייקט מורכב	מצוינים השלבים והתנאים של פלח הבקשה.
<Response>	אובייקט מורכב	מציינים את השלבים והתנאים של פלח התשובות.

<Flows>

מכיל אפס רכיבי <Flow> או יותר.

סוג	אובייקט מורכב
רכיבי הורה	<ProxyEndpoint> <TargetEndpoint>
רכיבי צאצא	<Flow>

אם יש כמה רכיבי <Flow> בתוך <Flows>, רק אחד מהם יופעל.<Flow> זה יהיה הרצף הראשון שלא מוגדר בו <Condition>, או שהתנאי שלו הוא true.

אתם יכולים להגדיר תהליך ברירת מחדל שתמיד יפעל (אם אף אחד מהתהליכים האחרים לא פועל). בהתאם להגדרות של ה-proxy ל-API, הוא יכול להיות כלי שימושי להגנה מפני מתקפות זדוניות.

תחביר

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

<Flows name="flow_name">
  <Flow name="conditional_flow_name">
    <Description>flow_description</Description>
    <Condition>property operator "value"</Condition>
    <Request>
      <Step>
        <Condition>property operator "value"</Condition>
        <Name>policy_name</Name>
      </Step>
      ...
    </Request>
    <Response>
      <Step>
        <Condition>property operator "value"</Condition>
        <Name>policy_name</Name>
      </Step>
      ...
    </Response>
  </Flow>
</Flows>

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

דוגמה 1

בדוגמה הבאה מוצג רכיב <Flows> פשוט עם <Flow> יחיד:

<!-- api-platform/reference/examples/flow-segments/flows-1.xml -->
<ProxyEndpoint name="default">
  <Flows name="my-conditional-flows">
    <Flow name="reports">
      <Request>
        <Description>Based on the path suffix, determine which flow to use</Description>
        <Step>
          <Condition>proxy.pathsuffix MatchesPath "/reports"</Condition>
          <Name>XML-to-JSON-1</Name>
        </Step>
        <Step>
          <Condition>proxy.pathsuffix MatchesPath "/forecasts"</Condition>
          <Name>Verify-Auth-1</Name>
        </Step>
      </Request>
    </Flow>
  </Flows>
  ...
</ProxyEndpoint>

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

דוגמה 2

בדוגמה הבאה מוצגים כמה רכיבי <Flow> בתוך <Flows>, שלכל אחד מהם יש <Condition> משלו:

<!-- api-platform/reference/examples/flow-segments/flows-2.xml -->
<ProxyEndpoint name="default">
  <Flows>
    <Flow name="my-flow-1">
      <Response>
        <Step>
          <Condition>response.status.code = 200</Condition>
          <Name>Assign-Message-1</Name>
        </Step>
      </Response>
    </Flow>
    <Flow name="my-flow-2">
      <Response>
        <Step>
          <Condition>response.status.code >= 400</Condition>
          <Name>Assign-Message-2</Name>
        </Step>
      </Response>
    </Flow>
    <Flow name="my-flow-3">
      <Response>
        <Step>
          <Condition>response.status.code >= 300</Condition>
          <Name>Assign-Message-3</Name>
        </Step>
      </Response>
    </Flow>
  </Flows>
  ...
</ProxyEndpoint>

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

דוגמה 3

בדוגמה הבאה מוצג <Flow> 'ברירת מחדל':

<!-- api-platform/reference/examples/flow-segments/flows-3.xml -->
<ProxyEndpoint name="default">
  <Flows>
    <Flow name="my-conditional-flow-1">
      <Response>
        <Step>
          <Condition>response.status.code = 200</Condition>
          <Name>Assign-Message-1</Name>
        </Step>
      </Response>
    </Flow>
    <Flow name="my-conditional-flow-2">
      <Response>
        <Step>
          <Condition>response.header.someheader = "42"</Condition>
          <Name>Assign-Message-2</Name>
        </Step>
      </Response>
    </Flow>
    <Flow name="my-default-flow">
      <Response>
        <Step>
          <Name>Assign-Message-3</Name>
        </Step>
      </Response>
    </Flow>
  </Flows>
  ...
</ProxyEndpoint>

מערכת Apigee מפעילה רק את הרצף הראשון בפלח שהתנאי שלו מחזיר את הערך true. אם לא מופעלים תהליכים מותנים, מופעל התהליך השלישי בדוגמה הזו (ללא תנאי).

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

מאפיינים

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

רכיבי צאצא

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

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

<Name>

המזהה של המדיניות להפעלה בתוך <Flow>.

סוג	String
רכיבי הורה	<Step>
רכיבי צאצא	ללא

תחביר

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

<Name>policy_name</Name>

דוגמה

בדוגמה הבאה מוצגות שתי מדיניות שנוספו לתהליכי עבודה לפי השם שלהן:

<!-- api-platform/reference/examples/flow-segments/name-1.xml -->
<ProxyEndpoint name="default">
  <Flows name="my-conditional-flows">
    <Flow name="reports">
      <Request>
        <Description>Based on the path suffix, determine which flow to use</Description>
        <Step>
          <Condition>proxy.pathsuffix MatchesPath "/reports"</Condition>
          <Name>XML-to-JSON-1</Name>
        </Step>
        <Step>
          <Condition>proxy.pathsuffix MatchesPath "/forecasts"</Condition>
          <Name>Verify-Auth-1</Name>
        </Step>
      </Request>
    </Flow>
  </Flows>
  ...
</ProxyEndpoint>

מאפיינים

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

רכיבי צאצא

לאלמנט <Name> אין רכיבי צאצא.

<PostFlow>

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

סוג	אובייקט מורכב
רכיבי הורה	<ProxyEndpoint> <TargetEndpoint>
רכיבי צאצא	<Description> <Request> <Response>

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

תחביר

<PostFlow name="flow_name">
  <Description>flow_description</Description>
  <Request>
    <Step>
      <Condition>property operator "value"</Condition>
      <Name>policy_name</Name>
    </Step>
    ...
  </Request>
  <Response>
    <Step>
      <Condition>property operator "value"</Condition>
      <Name>policy_name</Name>
    </Step>
    ...
  </Response>
</PostFlow>

דוגמה

בדוגמה הבאה מוצג PostFlow עם שלבים מוגדרים לבקשה ולתגובה:

<!-- api-platform/reference/examples/flow-segments/postflow-1.xml -->
<ProxyEndpoint name="default">
  <PostFlow name="my-postflows">
    <Description>My first PostFlow</Description>
    <Request>
      <Step>
        <Condition>request.verb = "GET"</Condition>
        <Name>Log-Request-OK</Name>
      </Step>
    </Request>
    <Response>
      <Step>
        <Name>Set-Response-Headers</Name>
      </Step>
    </Response>
  </PostFlow>
  ...
</ProxyEndpoint>

מאפיינים

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

מאפיין	סוג	תיאור
name	String	מזהה ייחודי של התהליך (ייחודי בנקודת הקצה). לדוגמה: My-PostFlow-1. הערך לא יכול לכלול רווחים או תווים מיוחדים אחרים.

רכיבי צאצא

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

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

<EventFlow>

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

סוג	אובייקט מורכב
רכיבי הורה	<TargetEndpoint>
רכיבי צאצא	<Description> <Response>

רכיב EventFlow משתמש בתחביר הבא:

תחביר

  <EventFlow name="flow_name" content-type="text/event-stream">>
    <Description>flow_description</Description>
    <Response>
      <Step>
        <Name>policy_name</Name>
      </Step>
    </Response>
  </EventFlow>

דוגמה

בדוגמה הבאה מוצג EventFlow:

<TargetEndpoint name="default">
  <EventFlow name="EF-1" content-type="text/event-stream">
    <Response>
      <Step>
        <Name>Raise-Fault-Cred-Invalid</Name>
        <Condition>fault.name equals "invalid_access_token"</Condition>
      </Step>
    </Response>
  </EventFlow>
  <HTTPTargetConnection>
</TargetEndpoint></pre>

מאפיינים

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

מאפיין	סוג	תיאור
name	String	מזהה ייחודי של התהליך (ייחודי בנקודת הקצה). לדוגמה: My-EventFlow-1. הערך לא יכול לכלול רווחים או תווים מיוחדים אחרים.
content-type	String	(חובה) הערך חייב להיות: content-type="text/event-stream"

רכיבי צאצא

בטבלה הבאה מתוארים רכיבי הצאצא של EventFlow:

רכיב צאצא	סוג	תיאור
<Description>	String	מספק תיאור קצר של התהליך.
<Response>	אובייקט מורכב	הגדרת המדיניות שתופעל במהלך EventFlow של התגובה.

<PostClientFlow>

מגדיר מדיניות ב-ProxyEndpoint שמופעלת רק אחרי שהתגובה מוחזרת ללקוח. בדרך כלל, ההודעות שקשורות לתגובה נרשמות ביומן של כללי המדיניות האלה.

סוג	אובייקט מורכב
רכיבי הורה	<ProxyEndpoint>
רכיבי צאצא	<Description> <Response>

תחביר

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

<PostClientFlow name="flow_name">
  <Description>flow_description</Description>
  <Response>
    <Step>
      <Condition>property operator "value"</Condition>
      <Name>policy_name</Name>
    </Step>
    ...
  </Response>
</PostClientFlow>

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

דוגמה

בדוגמה הבאה מוצג PostClientFlow פשוט שמבצע מדיניות אחת:

<!-- api-platform/reference/examples/flow-segments/postclientflow-1.xml -->
<ProxyEndpoint name="default">
  <PostClientFlow name="my-postclientflows">
    <Description>My first PostClientFlow. Processed after the response is sent back to the client.</Description>
    <Response>
      <Step>
        <Name>Message-Logging-OK</Name>
      </Step>
    </Response>
  </PostClientFlow>
  ...
</ProxyEndpoint>

מאפיינים

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

מאפיין	סוג	תיאור
name	String	מזהה ייחודי של התהליך. השם לא יכול לכלול רווחים או תווים מיוחדים אחרים. לדוגמה, My-PostClientFlow-1.

רכיבי צאצא

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

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

<PreFlow>

המאפיין הזה מגדיר את המדיניות שתופעל ב-PreFlow של הבקשה והתגובה.

סוג	אובייקט מורכב
רכיבי הורה	<ProxyEndpoint> <TargetEndpoint>
רכיבי צאצא	<Description> <Request> <Response>

תחביר

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

<PreFlow name="flow_name">
  <Description>flow_description</Description>
  <Request>
    <Step>
      <Condition>property operator "value"</Condition>
      <Name>policy_name</Name>
    </Step>
    ...
  </Request>
  <Response>
    <Step>
      <Condition>property operator "value"</Condition>
      <Name>policy_name</Name>
    </Step>
    ...
  </Response>
</PreFlow>

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

דוגמה

בדוגמה הבאה מוצג PreFlow עם בקשה וזרימת תגובה מוגדרות:

<!-- api-platform/reference/examples/flow-segments/preflow-1.xml -->
<ProxyEndpoint name="default">
  <PreFlow name="my-preFlows">
    <Description>My first PreFlow</Description>
    <Request>
      <Step>
        <Condition>request.verb = "GET"</Condition>
        <Name>Log-Request-OK</Name>
      </Step>
    </Request>
    <Response>
      <Step>
        <Condition>response.status.code LesserThanOrEquals 300</Condition>
        <Name>Log-Response-OK</Name>
      </Step>
      <Step>
        <Condition>response.status.code GreaterThan 300</Condition>
        <Name>Log-Response-NOT-OK</Name>
      </Step>
    </Response>
  </PreFlow>
  ...
</ProxyEndpoint>

מאפיינים

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

מאפיין	סוג	תיאור
name	String	מזהה ייחודי של התהליך. השם לא יכול לכלול רווחים או תווים מיוחדים אחרים. לדוגמה, My-PreFlow-1.

רכיבי צאצא

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

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

<Request>

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

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

תחביר

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

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

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

דוגמה

בדוגמה הבאה מוצגים רצפי פעולות שהוגדרו לבקשה ב-PreFlow וב-PostFlow:

<!-- api-platform/reference/examples/flow-segments/request-1.xml -->
<ProxyEndpoint name="default">
  <PreFlow name="my-preFlows">
    <Description>My first PreFlow</Description>
    <Request>
      <Step>
        <Condition>request.verb = "GET"</Condition>
        <Name>Log-Request-OK</Name>
      </Step>
    </Request>
  </PreFlow>
  <PostFlow name="my-postflows">
    <Description>My first PostFlow</Description>
    <Request>
      <Step>
        <Condition>request.verb = "GET"</Condition>
        <Name>Log-Request-OK</Name>
      </Step>
    </Request>
  </PostFlow>
  ...
</ProxyEndpoint>

מאפיינים

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

רכיבי צאצא

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

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

<Response>

המאפיין מגדיר את המדיניות שתופעל במהלך פלח התגובה של התהליך.

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

תחביר

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

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

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

דוגמה

בדוגמה הבאה מוצגים רכיבי Flow שהוגדרו לתגובה, גם ב-PreFlow וגם ב-PostFlow:

<!-- api-platform/reference/examples/flow-segments/response-1.xml -->
<ProxyEndpoint name="default">
    <PreFlow name="my-preFlows">
        <Description>My first PreFlow</Description>
        <Response>
            <Step>
                <Condition>response.status.code LesserThanOrEquals 300</Condition>
                <Name>Log-Response-OK</Name>
            </Step>
            <Step>
                <Condition>response.status.code GreaterThan 300</Condition>
                <Name>Log-Response-NOT-OK</Name>
            </Step>
        </Response>
    </PreFlow>
    <PostFlow name="my-postflows">
        <Description>My first PostFlow</Description>
        <Response>
            <Step>
                <Name>Set-Response-Headers</Name>
            </Step>
        </Response>
    </PostFlow>
  ...
</ProxyEndpoint>

מאפיינים

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

רכיבי צאצא

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

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

<Step>

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

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

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

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

תחביר

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

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

יכול להיות רק <Condition> אחד ורק <Name> אחד לכל <Step>, אבל יכולים להיות כמה שלבים ב-<Flow>.

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

דוגמה 1

בדוגמה הבאה מוצג שלב אחד עם תנאי ושלב אחד בלי תנאי:

<!-- api-platform/reference/examples/flow-segments/step-1.xml -->
<ProxyEndpoint name="default">
  <PostFlow name="my-postflows">
      <Description>My first PostFlow</Description>
      <Request>
          <Step>
              <Condition>request.verb = "GET"</Condition>
              <Name>Log-Request-OK</Name>
          </Step>
      </Request>
      <Response>
          <Step>
              <Name>Set-Response-Headers</Name>
          </Step>
      </Response>
  </PostFlow>
  ...
</ProxyEndpoint>

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

דוגמה 2

בדוגמה הבאה מוצגים כמה שלבים בפלח אחד:

<!-- api-platform/reference/examples/flow-segments/step-2.xml -->
<ProxyEndpoint name="default">
    <PostFlow name="PostFlow">
        <Response>
            <Step>
                <Name>Assign-Message-1</Name>
            </Step>
            <Step>
                <Name>Assign-Message-2</Name>
            </Step>
        </Response>
    </PostFlow>
  ...
</ProxyEndpoint>

שלבים ללא תנאי תמיד מבוצעים.

מאפיינים

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

רכיבי צאצא

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

רכיב צאצא	סוג	תיאור
<Condition>	String	הגדרת משפט מותנה לשלב שמעובד בזמן הריצה. אם הערך של המשפט הוא true, ‏ Apigee מבצע את השלב. אם הערך של ההצהרה הוא false, המערכת של Apigee מדלגת על השלב.
<Name>	String	מציינים את מזהה המדיניות שרוצים להפעיל בתהליך הנוכחי.