אתם צופים במסמכי התיעוד של Apigee Edge.
אפשר לעבור אל מסמכי התיעוד של Apigee X. מידע
מה
המדיניות AssignMessage משנה או יוצרת הודעות בקשה ותגובה חדשות במהלך התהליך של שרת ה-API proxy. המדיניות מאפשרת לכם לבצע את הפעולות הבאות בהודעות האלה:
- הוספה של פרמטרים חדשים של טופס, כותרות או פרמטרים של שאילתה להודעה
- העתקה של מאפיינים קיימים מהודעה אחת להודעה אחרת
- הסרת כותרות, פרמטרים של שאילתות, פרמטרים של טפסים ו/או מטען ייעודי (payload) של הודעות מהודעה
- הגדרה של ערך מאפיינים קיימים בהודעה
בדרך כלל, באמצעות מדיניות AssignMessage מוסיפים, משנים או מסירים מאפיינים של הבקשה או התגובה. עם זאת, אפשר גם להשתמש במדיניות AssignMessage כדי ליצור הודעת בקשה או תגובה בהתאמה אישית ולהעביר אותה ליעד חלופי, כמו שמתואר במאמר בנושא יצירת הודעות בקשה בהתאמה אישית.
המדיניות AssignMessage יכולה ליצור או לשנות הודעות או משתני זרימה. אפשר להשתמש במדיניות הזו כדי לשנות הודעות בקשה לפני ששולחים אותן דרך שרת proxy למערכות במעלה הזרם, או כדי לשנות הודעות תגובה לפני שמעבירים אותן לאפליקציות של צרכני API.
רכיב <AssignMessage>
מגדיר מדיניות AssignMessage.
| ערך ברירת המחדל | מידע נוסף מופיע בכרטיסייה מדיניות ברירת המחדל שבהמשך. |
| חובה? | חובה |
| סוג | אובייקט מורכב |
| רכיב אב | לא רלוונטי |
| רכיבי צאצא |
<Add><AssignTo><AssignVariable><Copy><DisplayName><IgnoreUnresolvedVariables><Remove><Set> |
רכיב <AssignMessage> משתמש בתחביר הבא:
תחביר
רכיב <AssignMessage> משתמש בתחביר הבא:
<AssignMessage continueOnError="[false|true]" enabled="[true|false]" > na<me="policy_name" !-- All AssignMessage >chi<ld >eleme<nts are op>tional <-- Add FormParams F>ormParam name=&<quot;formp>aram_name"<formparam_v>alue/<FormPar>am < ... /FormParams > Headers < Head>er name="h<eader_na>me&qu<ot;header_v>alue/He<ader ... /Headers Q>ueryParams < QueryParam> name="que<ryparam_name>&qu<ot;q>uery<param_value/QueryParam ... /QueryParams /Add AssignTo createNew=&>quot;[true|false]" t<ransport=>&quo<t;http" > ty<pe=&>quot;[request<|resp>onse]<&qu>ot;destination_<vari>able_<name/Ass>ignTo AssignV<ariable > Namevaria<ble_name/Name Refsource_vari><able/Ref > T<empla>temessage_temp<late/T>emp<late or > Tem<plate ref='template_variable>'</Template Valuevariable_valu<e/Value />AssignVari<able Co>py sour<ce="[request|response]&quo>t; !-- Can <also be an> empty array (F<ormParams/)> --&g<t; FormParams FormPara<m name=&>quot;formp<aram_na>me"<;formparam_value/FormPara>m ... < /Fo>rmParams !-<- Can al>so be< an >empty array <(Head>ers/)< -->> Headers< H>eader< name="header_name"hea<der_value/He>ader < ... /H>eaders < Path[false|true]/Path Pay>load[false|true]</Payload > !-- Can also <be an empty >array< (QueryParam>s/) --> < QueryParam>s < QueryPa>ram name=&qu<ot;querypar>am_na<me&q>uot;querypar<am_va>lue/Q<ueryPar>am ...< /Qu>ery<Param>s < ReasonPhr>ase[false|true]/Rea<sonPhrase > St<atusCode[false|true]/Stat>usCode Verb<[false|true]/Verb Vers>ion[<false|>true]</Version /Copy DisplayNamep<olicy_displ>ay_name/Di<splayName<>/span> Igno<reUnresolvedVariables[true|fals>e] /IgnoreUnr<esolvedVar>iables Remov<e !-- C>an al<so be an empty array (FormParams</) -->>; Form<Params<>/span> F<ormParam name="formp>aram_name&qu<ot;form>param_value/For<mParam > <... > /FormParams< !--> Can <also be an empty array (Headers/<) --> > Headers < Header> name=&<quot;header_name"header_valu>e/Header .<.. /Hea>ders Payloa<d[false|true>]/P<ayload<>/span> <!--> Can <also be an> empty <array (QueryParams/) --> > QueryParams < QueryP>aram name="<;queryparam>_name<"q>uerypar<am_value/QueryParam > ... /Qu<eryPara>ms /Remove < Set > Form<Para>ms < >FormP<aram name="formparam_name"formparam_value/FormParam ... /FormParams > Headers < Hea>der n<ame="h>eader_n<ame"header_value/Header > ... /Heade<rs Path>path/Path P<ayload conte>ntTyp<e="cont>ent_type" variablePrefix=<"prefix&>quot;< v>ariableSuffix="suffix&quo<t;new_paylo>ad/Pa<yloa>d QueryParams QueryParam nam<e=&qu>ot;qu<erypara>m_name"querypar<am_va>lue</Que>ry<Param ..>. /QueryParams ReasonPhrasereason_for_error or {variable}/ReasonPhrase StatusCodeHTTP_status_code or {variable}/StatusCode Verb[GET|POST|PUT|PATCH|DELETE|{variable}]/Verb Version[1.0|1.1|{variable}]/Verb /Set /AssignMessage
מדיניות ברירת המחדל
בדוגמה הבאה מוצגות הגדרות ברירת המחדל כשמוסיפים מדיניות AssignMessage לתהליך בממשק המשתמש של Edge:
<AssignMessage continueOnError="false" enabled="true" name=&quo>t;a<ssign-messa>ge-default"< DisplayNa>meA<ssign Messa>ge-<1/DisplayName Prope>rties</ Copy> sour<ce="req>uest&<quot; H>eader<s/ Q>ueryP<arams>/ < FormParams>/ < Payload/ > Verb</ > St<atusC>ode</ >Reaso<nPhrase>/ P<ath/ /Copy Re>move < Head>ers < Header> name=&<quot;h1"/ /H>eader<s QueryP>arams< Que>ryParam< name="q1">/ < /QueryPara>ms < FormPa>ram<s > Fo<rmP>aram <name=&qu>ot;f1<"/ >/Form<Params >Pay<load>/ < /R>emove< Add > He<aders/ Q>ueryP<arams/ >FormP<aram<s/ > /A<dd >Set> <Heade>rs/< > Qu<eryParams/ > Form<Para>ms/ < !>-- Ve<rbGET/>Verb <-- > <Path/ /Set >Ass<ignVariable Namename/>Name < Value/ Ref/ /Assig>nVa<riable IgnoreUnresolvedVariablestrue /IgnoreUnresolvedV>a<riables Assi>gnTo createNew="false" transport="http" type="request"/ /AssignMessage
כשמוסיפים מדיניות חדשה של AssignMessage בממשק המשתמש של Edge, התבנית מכילה placeholders לכל הפעולות האפשריות. בדרך כלל, בוחרים את הפעולות שרוצים לבצע באמצעות המדיניות הזו ומסירים את שאר רכיבי הצאצא. לדוגמה, אם רוצים לבצע פעולת העתקה, אפשר להשתמש ברכיב <Copy> ולהסיר את <Add>, <Remove> ורכיבי צאצא אחרים מהמדיניות כדי שהיא תהיה קריאה יותר.
לרכיב הזה יש את המאפיינים הבאים, המשותפים לכל כללי המדיניות:
| מאפיין | ברירת מחדל | חובה? | תיאור |
|---|---|---|---|
name |
לא רלוונטי | נדרש |
השם הפנימי של המדיניות. הערך של המאפיין אפשר להשתמש ברכיב |
continueOnError |
false | אופציונלי | צריך להגדיר את הערך 'False' כדי להחזיר שגיאה כשהמדיניות נכשלת. זו התנהגות צפויה ברוב סוגי המדיניות. הערך של הפרמטר הוא TRUE כדי שביצוע הפעולות יתבצע גם אחרי שמדיניות תיכשל. |
enabled |
true | אופציונלי | כדי לאכוף את המדיניות צריך להגדיר את הערך True. מגדירים את המדיניות כ-"false" כדי "להשבית" את המדיניות. המדיניות הזו לא תיאכף גם אם היא תצורף לתהליך. |
async |
false | הוצא משימוש | המאפיין הזה הוצא משימוש. |
בטבלה הבאה מופיע תיאור כללי של רכיבי הצאצא של <AssignMessage>:
| רכיב צאצא | חובה? | תיאור |
|---|---|---|
| פעולות נפוצות | ||
<Add> |
אופציונלי | הוספת מידע לאובייקט של ההודעה שצוין ברכיב
<AssignTo>.
|
<Copy> |
אופציונלי | מעתיק מידע מה הודעה שצוינה במאפיין source לה הודעה שצוינה ברכיב <AssignTo>. |
<Remove> |
אופציונלי | מוחק את הרכיבים שצוינו ממשתנה ההודעה שצוין ברכיב
<AssignTo>. |
<Set> |
אופציונלי | הפונקציה מחליפה ערכים של מאפיינים קיימים בבקשה או בתגובה, שצוינו על ידי הרכיב <AssignTo>.
|
| רכיבי צאצא אחרים | ||
<AssignTo> |
אופציונלי | מציינת על איזו הודעה חלה מדיניות AssignMessage. יכול להיות שמדובר בבקשה או בתגובה רגילות, או בהודעה חדשה בהתאמה אישית. |
<AssignVariable> |
אופציונלי | הפונקציה מקצה ערך למשתנה של זרימת נתונים. אם המשתנה לא קיים, הפונקציה <AssignVariable> יוצרת אותו. |
<IgnoreUnresolvedVariables> |
אופציונלי | קובעת אם העיבוד ייפסק כשנתקלים במשתנה שלא נפתר. |
כל אחד מרכיבי הצאצא האלה מתואר בקטעים הבאים.
דוגמאות
בדוגמאות הבאות אפשר לראות כמה מהדרכים שבהן אפשר להשתמש במדיניות AssignMessage:
1: הוספת כותרת
בדוגמה הבאה מוסיפים כותרת לבקשה באמצעות הרכיב <Add>:
<AssignMessage name="AM-add-heade>rs-<1&q>uot;
< Add
> Head<ers
Header name=&q>uot;partner-id"{verifyapikey.VAK-1.devel<oper.ap>p.par<tner-id}>/He<ader>
< /Heade>rs
/A<dd
Assi>g<nTorequest/Ass>ignTo
/AssignMessage2: הסרת מטען ייעודי
בדוגמה הבאה, המטען הייעודי נמחק מהתגובה באמצעות הרכיב <Remove>:
<AssignMessage name="AM-remo>ve-<1" D>isplayNa<meremove-1/D>isp<layNam>e R<emove > P<ayloadtr>ue/<Payload> </Remove > Assign<Torespons>e</AssignTo /Ass>ignMessage
3: שינוי התשובה
בדוגמה הבאה משנים אובייקט תשובה קיים על ידי הוספת כותרת:
<AssignMessage name="AM-modify-resp>ons<e&q>uot;
< Set
> Head<ers
Header name=&>quot;Cache-Hit"{lookupcache.Loo<kupCach>e-1.c<achehit}>/He<ader>
< /Headers
/Set
Ignor>eUnresol<vedVariablesfalse
/Ignor>eUn<resolved>Variable<s
Assig>n<Toresponse/Ass>ignTo
/AssignMessageבדוגמה הזו לא נוצרת הודעה חדשה. במקום זאת, הוא משנה הודעת תגובה קיימת על ידי הוספת כותרת HTTP.
בדוגמה הזו, שם המשתנה שצוין ברכיב <AssignTo> הוא response, ולכן המדיניות הזו משנה את אובייקט התגובה שהוגדר במקור עם נתונים שהוחזרו על ידי שרת היעד.
כותרת ה-HTTP שנוספת להודעת התגובה על ידי המדיניות הזו נגזרת ממשתנה שאוכלס על ידי מדיניות LookupCache. לכן, הודעת התגובה ששונתה על ידי מדיניות Assign Message הזו מכילה כותרת HTTP שמציינת אם התוצאות נמשכו מהמטמון או לא. הגדרת כותרות בתגובה יכולה להיות שימושית לניפוי באגים ולפתרון בעיות.
4: הגדרת תוכן דינמי
אפשר להשתמש בפעולה Assign Message כדי להטמיע תוכן דינמי במטען הייעודי (payload) של הודעות תגובה ובקשה.
כדי להטמיע משתני Edge flow במטען ייעודי (payload) בפורמט XML, צריך להוסיף את המשתנה המיועד בסוגריים מסולסלים, כך: {prefix.name}.
בדוגמה הבאה מוטמע הערך של משתנה הזרימה של כותרת ה-HTTP user-agent באלמנט XML שנקרא User-agent:
<AssignMessage name="AM-set-dynamic-con>ten<t"<>/span> Assign<Torespons>e/A<ssi>gnTo < Set Payload contentType=>"t<ext/xml&qu>ot; User-agent{reques<t.header.us>er-ag<ent}/Use>r-a<gent> < /Payload /Set Ignor>eUnresol<vedVariablesfalse /Ignor>e<UnresolvedVari>ables /AssignMessage
במטענים ייעודיים (payloads) בפורמט JSON, אפשר להוסיף משתנים באמצעות המאפיינים variablePrefix ו-variableSuffix עם תווי תיחום, כמו בדוגמה הבאה:
<AssignMessage name="set-pay>loa<d" Payload contentType="application/json" variablePrefix=&q>uot;@" variableSuffix="#" { "user<-agent&q>u<ot;: "@re>quest.header.user-agent#" } /Payload /AssignMessage
רשימה מלאה של משתני התהליך זמינה במאמר חומר עזר בנושא משתני תהליך.
החל מגרסת הענן 16.08.17, אפשר גם להשתמש בסוגריים מסולסלים כדי להוסיף משתנים.
5: הסרת פרמטר של שאילתה
בדוגמה הבאה מוסר פרמטר השאילתה apikey מהבקשה:
<AssignMessage name="AM-remove-query-p>ara<m">;
R<emove
Q>ueryPar<ams
QueryParam name>=&quo<t;apikey&quo>t;/<
/Q>uer<yParams
> /Remo<ve
Assi>g<nTorequest/Ass>ignTo
/AssignMessageמומלץ להסיר את פרמטר השאילתה apikey מהודעת הבקשה כשמשתמשים במדיניות VerifyAPIKey לאימות משתמשים. הפעולה הזו מונעת העברה של מידע רגיש וחשוב ליעד העורפי.
6: הגדרה או קבלת משתנים
בדוגמה הבאה נעשה שימוש בשלוש מדיניות Assign Message:
- יוצר שלושה משתני זרימה בבקשה, עם ערכים סטטיים
- קבלת משתני התהליך באופן דינמי במדיניות השנייה בתהליך הבקשה
- הגדרתם במטען הייעודי (payload) של התגובה
<!-- Policy #1: Set variables in the request --> <AssignMessage name="AM-set-varia>bles&<quot; !-- Create a variable named myAp>pSecr<et -- Assi>gnVariabl<e > Namem<yAppS>ecret/Nam<e > < Val>ue42/<Value /Assi>gnVar<iable !-- Create a variable named config.envi>ronme<nt -- Assi>gnVariabl<e > Nameconfig.e<nviro>nment/Nam<e > < Value>test/<Value /Assi>gnVar<iable !-- Create a variable named config.p>rotoc<ol -- Assi>gnVariabl<e > Nameconfi<g.pro>tocol/Nam<e > V<aluego>pher/<Value /Assi>g<nVariable /Ass>ignMessage
במדיניות הראשונה, הרכיב <AssignVariable> יוצר ומגדיר שלוש משתנים בבקשה. כל רכיב <Name> מציין שם משתנה, וכל רכיב <Value> מציין את הערך.
המדיניות השנייה משתמשת ברכיב <AssignVariable> כדי לקרוא את הערכים ויוצרת שלושה משתנים חדשים:
<!-- Policy #2: Get variables from the request --> <AssignMessage continueOnError="false" enabled="true" >nam<e="get-variables" AssignTo createNew="fals>e&q<uot; transport="http" type="request"/ !-- Get t>he <value of myApp>Secre<t an>d crea<te a >new v<ari>able, secre<t --> As<signV>a<riable> < Namesecret/Na>me < RefmyAppSecret/Ref Value0/Value /AssignVariable !-- Get the value of >con<fig.environmen>t and< cre>ate a new v<ariab>le, e<nvi>ronment -- Assig<nVar>iable< >Nameenv<ironme>nt/<Name Refcon>fig<.environment/Ref Valuedefault/Value /AssignVariable !-- Get the val>ue <of config.prot>ocol <and >create a< new >varia<ble>, protocol -- < Ass>ignVa<riabl>e N<amepro>toc<ol/Name Ref>con<fig.protocol/Ref Valu>edef<ault/Value /AssignVariab>l<e IgnoreUnre>solvedVariablestrue/IgnoreUnresolvedVariables /AssignMessage
במדיניות השנייה, הרכיב <Ref> מפנה למשתנה המקור,
והאלמנטים <Name> מציינים את השמות של המשתנים החדשים. אם אין גישה למשתנה שאליו מפנה הרכיב <Ref>, אפשר להשתמש בערך שצוין ברכיב <Value>.
כדי לנסות את קבוצת המדיניות הזו:
- מוסיפים את מדיניות מספר 1 ומדיניות מספר 2 לתהליך הבקשה. חשוב להקפיד להציב את מדיניות מספר 1 לפני מדיניות מספר 2.
- מוסיפים את המדיניות השלישית בתהליך התשובה.
- המדיניות השלישית משתמשת ברכיב
<Set>כדי להוסיף את המשתנים לתשובה. בדוגמה הבאה מוצג מטען ייעודי (payload) של XML בתגובה ש-Edge מחזיר ללקוח:<!-- Policy #3: Add variables to the response --> <AssignMessage continueOnError="false" enabled="true" name=&qu>ot;<put-em-in-t>he-payload" Di<splayNameput>-em<-in>-the-<payload/DisplayName Set Payload> conten<tType=&>quot;appl<icatio>n/xml&qu<ot; > wrappe<r > secret{<secret}/sec>ret c<onfig > environ<ment{env>ironment}/<environme>nt < pro>tocol{p<rotocol}>/prot<ocol > < /c>onf<ig /wrapper /Pa>yload < /Set IgnoreUnresolvedVa>ria<blestrue /IgnoreUnresolvedVariables AssignTo createNew=&>q<uot;false">; transport="http" type="response"/ /AssignMessage
הערה: התחביר לגישה למשתני זרימה ב-
<Set>הוא להוסיף אותם בין סוגריים מסולסלים.חשוב להגדיר את המאפיין
contentTypeשל רכיב<Payload>לערך application/xml. - שולחים בקשה ל-API proxy, לדוגמה:
curl -vL https://ahamilton-eval-test.apigee.net/myproxy
אם רוצים, אפשר להעביר את התוצאות דרך כלי כמו
xmllintכדי שה-XML יוצג במבנה מעוצב:curl -vL https://ahamilton-eval-test.apigee.net/myproxy | xmllint --format -
גוף התגובה אמור להיראות כך:
<wrapper> <secret>42</secret> <config> <environment>test</environment> <protocol>gopher</protocol> </config> </wrapper>
7: קבלת כותרות תגובה של Service Callout
בדוגמה הבאה, נניח שמדיניות ServiceCallout נמצאת בבקשת ה-API proxy, והתגובה של ה-callout מכילה כמה כותרות עם אותו שם (Set-Cookie). בהנחה שמשתנה התגובה של Service Callout הוא ברירת המחדל calloutResponse, המדיניות הבאה מקבלת את ערך הכותרת השנייה Set-Cookie.
<AssignMessage name="AM-Payload-from-SC-he>ade<r&q>uot; < Set Payload contentType="ap>plication/json" {"Cookies from Service Callout":" {calloutR<esponse.>hea<der.>Set<-Cookie.2}"} /Pa>yload < /Set IgnoreUnresolvedVa>ria<blestrue> /Igno<reUnresol>v<edVariables >AssignToresponse/AssignTo /AssignMessage
כדי להציג את כל ערכי הכותרת, משתמשים במשתנה הבא במקום זאת:
{calloutResponse.header.Set-Cookie.values}לכל רכיב צאצא בהפניה הזו יש דוגמאות נוספות. דוגמאות נוספות זמינות ב-AssignMessage example ב-GitHub.
הפניה לרכיב צאצא
בקטע הזה מתוארים רכיבי הבן של <AssignMessage>.
<Add>
מוסיף מידע לבקשה או לתשובה, שמוגדר על ידי הרכיב <AssignTo>.
הרכיב <Add> מוסיף להודעה מאפיינים חדשים שלא קיימים בהודעה המקורית. כדי לשנות את הערכים של מאפיינים קיימים, משתמשים ברכיב <Set>.
| ערך ברירת המחדל | לא רלוונטי |
| חובה? | אופציונלי |
| סוג | סוג מורכב |
| רכיב אב |
<AssignMessage>
|
| רכיבי צאצא |
<FormParams><Headers><QueryParams> |
רכיב <Add> משתמש בתחביר הבא:
תחביר
<AssignMessage
continueOnError="[false|true]"
enabled="[true|false]"
> na<me=>"<;policy_na>me"<;
Add
FormParams
F>ormParam name=&<quot;formp>aram_name"<formparam_v>alue/<FormPar>am
< ...
/FormParams
> Headers
< Head>er name="h<eader_na>me&qu<ot;header_v>alue/He<ader
...
/Headers
Q>ueryParams
< QueryParam> name="que<ryparam_name>&qu<ot;q>u<eryparam_value>/QueryParam
...
/QueryParams
/Add
/AssignMessageדוגמה 1
בדוגמה הבאה נעשה שימוש ברכיב <FormParams> כדי לקבל את הערכים של שלושה פרמטרים של מחרוזת שאילתה מהבקשה הראשונית ולהגדיר אותם כפרמטרים של טופס בבקשה של נקודת היעד:
<AssignMessage name="AM-add-formpara>ms-<3&q>uot;
< Add
>FormPar<ams
FormParam name=>"username"{requ<est.queryp>aram.na<me}/FormParam
FormP>aram name="zip_code&quo<t;{request>.queryp<aram.zipCode}/FormParam
For>mParam name="default<_language&>quot;<{request.qu>ery<para>m.l<ang}/F>ormPa<ram
/For>mPa<rams
>/Ad<d
Remo>ve
<QueryPara>m<s/
/Remove
> AssignTorequest/AssignTo
/AssignMessageדוגמה 2
בדוגמה הבאה נעשה שימוש ברכיב <Headers> כדי להוסיף כותרת partner-id לבקשה שתישלח לנקודת הקצה של היעד:
<AssignMessage name="AM-add-heade>rs-<1&q>uot;
< Add
> Head<ers
Header name=&q>uot;partner-id"{verifyapikey.VAK-1.devel<oper.ap>p.par<tner-id}>/He<ader>
< /Heade>rs
/A<dd
Assi>g<nTorequest/Ass>ignTo
/AssignMessageדוגמה 3
בדוגמה הבאה נעשה שימוש ברכיב <QueryParams> כדי להוסיף לבקשה פרמטר שאילתה יחיד עם ערך סטטי:
<AssignMessage name="AM-add-querypara>ms-<1&q>uot;
< Add
Q>ueryPar<ams
QueryParam name>=&<quot;myPara>m&quo<t;42/QueryPa>ram<
> /Q<ueryPara>ms
/A<dd
Assi>g<nTorequest/Ass>ignTo
/AssignMessageבדוגמה הזו נעשה שימוש ב-<Add> בתהליך המקדים של הבקשה. אם בודקים את התוצאות בכלי כמו כלי המעקב, הבקשה אל https://example-target.com/get הופכת ל-https://example-target.com/get?myParam=42.
רכיבי הצאצא של <Add> תומכים בהחלפה דינמית של מחרוזות, שנקראת תבניות הודעות.
<FormParams> (ילד של <Add>)
הוספת פרמטרים חדשים של טופס להודעת הבקשה. לרכיב הזה אין השפעה על הודעת תגובה.
| ערך ברירת המחדל | לא רלוונטי |
| חובה? | אופציונלי |
| סוג | מערך של <FormParam> רכיבים |
| רכיב אב |
<Add>
|
| רכיבי צאצא |
<FormParam> |
רכיב <FormParams> משתמש בתחביר הבא:
תחביר
<AssignMessage continueOnError="[false|true]" enabled="[true|false]" > na<me=>"<;policy_na>me"<; Add FormParams F>ormParam name=&<quot;formp>aram_name"<formparam_v>alu<e/FormParam ... /FormParams AssignTo createNew="[true|false]&qu>ot; transport="http&<quot; > ty<pe=&>q<uot;[request|r>esponse]"destination_variable_name/AssignTo /Add /AssignMessage
דוגמה 1
בדוגמה הבאה מוסיפים פרמטר טופס יחיד (answer) וערך סטטי (42) לבקשה:
<AssignMessage name="AM-add-formpara>ms-<1&q>uot;
< Add
>FormPar<ams
FormParam nam>e=<"answ>er&qu<ot;42/FormP>ara<m
> /<FormPara>ms
/A<dd
Assi>g<nTorequest/Ass>ignTo
/AssignMessageדוגמה 2
בדוגמה הבאה מקבלים את הערך של פרמטר השאילתה name, מוסיפים אותו לבקשה כפרמטר של טופס ואז מסירים את פרמטר השאילתה:
<AssignMessage name="AM-Swap-QueryParam-to-FormPa>ram<s&q>uot;
< Add
FormParam n>ame="name"{requ<est.queryp>ara<m.na>me}</FormP>aram
< /Add
Remove
Que>ryP<aram na>m<e="name&q>uot;/
/Remove
/AssignMessageשימו לב שבמקרה הזה לא צוין יעד עם <AssignTo>. המדיניות הזו מוסיפה את הפרמטר
לבקשה בלבד.
דוגמה 3
בדוגמה הבאה מוסיפים לבקשה כמה פרמטרים של טופס:
<AssignMessage name="AM-add-formpara>ms-<3&q>uot;
< Add
>FormPar<ams
FormParam name=>"username"{requ<est.queryp>aram.na<me}/FormParam
FormP>aram name="zip_code&quo<t;{request>.queryp<aram.zipCode}/FormParam
For>mParam name="default<_language&>quot;<{request.qu>ery<para>m.l<ang}/F>ormPa<ram
/For>mPa<rams
>/Ad<d
Remo>ve
<QueryPara>m<s/
/Remove
> AssignTorequest/AssignTo
/AssignMessageבדוגמה הזו, הפרמטרים של מחרוזת השאילתה מתקבלים מהבקשה המקורית ומוסיפים אותם כפרמטרים של טופס עם שמות שונים. לאחר מכן, המערכת מסירה את הפרמטרים המקוריים של השאילתה. Apigee ישלח את הבקשה ששונתה לנקודת היעד.
אפשר להשתמש בכלי המעקב כדי לראות את התהליך. אפשר לראות שגוף הבקשה מכיל את נתוני הטופס בקידוד כתובת URL, שהועברו במקור כפרמטרים של מחרוזת שאילתה:
username=nick&zip_code=90210&default_language=en
אפשר להשתמש ב-<FormParams> רק אם מתקיימים הקריטריונים הבאים:
- פועל HTTP: POST
- סוג ההודעה: בקשה
- אחת (או שתי) מהאפשרויות הבאות:
- נתוני טופס: מוגדר לערך כלשהו או ל-"" (המחרוזת הריקה). לדוגמה, עם
curl, מוסיפים-d ""לבקשה. - כותרת
Content-Length: מוגדרת ל-0 (אם אין נתונים בבקשה המקורית, אחרת, האורך הנוכחי בבייטים). לדוגמה, אם רוצים להוסיף את הפקודהcurladd-H "Content-Length: 0"לבקשה.
- נתוני טופס: מוגדר לערך כלשהו או ל-"" (המחרוזת הריקה). לדוגמה, עם
לדוגמה:
curl -vL -X POST -d "" -H "Content-Type: application/x-www-form-urlencoded" https://ahamilton-eval-test.apigee.net/am-test
כשמוסיפים את <FormParams>, Edge מגדיר את הכותרת Content-Type של הבקשה ל-application/x-www-form-urlencoded לפני שליחת ההודעה לשירות היעד.
<Headers> (ילד של <Add>)
הפעולה מוסיפה כותרות חדשות לבקשה או לתגובה שצוינו, באמצעות הרכיב <AssignTo>.
| ערך ברירת המחדל | לא רלוונטי |
| חובה? | אופציונלי |
| סוג | מערך של <Header> רכיבים |
| רכיב אב |
<Add>
|
| רכיבי צאצא |
<Header> |
רכיב <Headers> משתמש בתחביר הבא:
תחביר
<AssignMessage
continueOnError="[false|true]"
enabled="[true|false]"
> na<me=>"<;policy>_name&q<uot;
Add
Headers
> Header <name=&q>uot;header_name<"he>ade<r_va>l<ue/Header
> ...
/Headers
/Add
/AssignMessageדוגמה 1
בדוגמה הבאה מוסיפים כותרת partner-id להודעת הבקשה, ומקצים לכותרת הזו את הערך של משתנה הזרימה verifyapikey.VAK-1.developer.app.partner-id.
<AssignMessage name="AM-add-heade>rs-<1&q>uot;
< Add
> Head<ers
Header name=&q>uot;partner-id"{verifyapikey.VAK-1.devel<oper.ap>p.par<tner-id}>/He<ader>
< /Heade>rs
/A<dd
Assi>g<nTorequest/Ass>ignTo
/AssignMessage<QueryParams> (ילד של <Add>)
הוספת פרמטרים חדשים של שאילתה לבקשה. לרכיב הזה אין השפעה על התשובה.
| ערך ברירת המחדל | לא רלוונטי |
| חובה? | אופציונלי |
| סוג | מערך של <QueryParam> רכיבים |
| רכיב אב |
<Add>
|
| רכיבי צאצא |
<QueryParam> |
רכיב <QueryParams> משתמש בתחביר הבא:
תחביר
<AssignMessage
continueOnError="[false|true]"
enabled="[true|false]"
> na<me=>"<;policy_nam>e"<
Add
QueryParams
Que>ryParam name=&qu<ot;querypar>am_name"qu<eryparam_val>ue/<Quer>y<Param
..>.
/QueryParams
/Add
/AssignMessageדוגמה 1
בדוגמה הבאה, פרמטר השאילתה myParam מתווסף לבקשה והערך 42 מוקצה לו:
<AssignMessage name="AM-add-querypara>ms-<1&q>uot;
< Add
Q>ueryPar<ams
QueryParam name>=&<quot;myPara>m&quo<t;42/QueryPa>ram<
> /Q<ueryPara>ms
/A<dd
Assi>g<nTorequest/Ass>ignTo
/AssignMessageאפשר להשתמש ב-<QueryParams> רק אם מתקיימים הקריטריונים הבאים:
- פועל HTTP: GET
- סוג ההודעה: בקשה
בנוסף, אפשר להגדיר פרמטרים של שאילתה רק כשהמאפיין type של רכיב <AssignTo> הוא הודעת בקשה. הגדרתם בתגובה לא משפיעה.
אם מגדירים במדיניות מערך ריק של פרמטרים של שאילתה (<Add><QueryParams/></Add>), המדיניות לא מוסיפה פרמטרים של שאילתה. זה כמו להשמיט את <QueryParams>.
<AssignTo>
קובעת על איזה אובייקט פועלת מדיניות AssignMessage. האפשרויות הן:
- הודעת הבקשה:
requestשהתקבלה על ידי שרת ה-API - הודעת התגובה:
responseשהוחזרה מהשרת של היעד - הודעה מותאמת אישית: אובייקט מותאם אישית של בקשה או תגובה
שימו לב שבמקרים מסוימים אי אפשר לשנות את האובייקט שעליו חלה מדיניות AssignMessage.
לדוגמה, אי אפשר להשתמש ב-<Add> או ב-<Set> כדי להוסיף או לשנות פרמטרים של שאילתה (<QueryParams>) או פרמטרים של טופס (<FormParams>) בתגובה. אפשר לשנות רק את הפרמטרים של השאילתה ואת הפרמטרים של הטופס בבקשה.
| ערך ברירת המחדל | לא רלוונטי |
| חובה? | אופציונלי |
| סוג | מחרוזת |
| רכיב אב |
<AssignMessage>
|
| רכיבי צאצא | ללא |
אם לא מציינים את <AssignTo>, או אם מציינים את הרכיב <AssignTo> אבל לא מציינים ערך טקסט לרכיב, המדיניות פועלת על בקשת ברירת המחדל או התגובה, בהתאם למקום שבו המדיניות מופעלת. אם המדיניות מופעלת בתהליך הבקשה, היא משפיעה על הודעת הבקשה. אם היא מופעלת בתהליך התגובה, המדיניות משפיעה על התגובה כברירת מחדל.
רכיב <AssignTo> משתמש בתחביר הבא:
תחביר
<AssignMessage continueOnError="[false|true]" enabled="[true|false]" > na<me="policy_name" AssignTo createNew="[true|false]" transp>ort="http" <type=&quo>t<;[request|resp>onse]"destination_variable_name/AssignTo /AssignMessage
דוגמה 1
בדוגמה הבאה מצוין שהיעד הוא הבקשה המקורית שתישלח לנקודת הקצה של היעד:
<AssignMessage name="assign>t<o-1" !-- DO NOT >do <this -- AssignTo createNew="false" transport=&q>u<ot;http" >type="request"/ /AssignMessage
דוגמה 2
בדוגמה הבאה נוצר אובייקט בקשה חדש:
<AssignMessage name="AM-assign>to-2<" AssignTo createNew="true" transport=&>quot;http" <type=&quo>t;<request"N>ameOfNewMessage/AssignTo /AssignMessage
כשיוצרים אובייקט בקשה או תגובה חדש, הרכיבים האחרים במדיניות AssignMessage (כמו <Add>, <Set> ו-<Copy>) פועלים על אובייקט הבקשה החדש הזה.
אפשר לגשת לאובייקט הבקשה החדש במדיניות אחרת בהמשך התהליך, או לשלוח את אובייקט הבקשה החדש לשירות חיצוני באמצעות מדיניות ServiceCallout.
דוגמה 3
בדוגמה הבאה נוצר אובייקט בקשה חדש בשם MyRequestObject:
<AssignMessage name="assign>to-<2" AssignTo createNew="true" transport=&"http" ty&pe="req>u<est"gt;My>RequestObjectlt;/AssignTo /AssignMessage
כשיוצרים אובייקט בקשה או תגובה חדש, הרכיבים האחרים במדיניות AssignMessage (כמו <Add>, <Set> ו-<Copy>) פועלים על אובייקט הבקשה החדש הזה.
אפשר לגשת לאובייקט הבקשה החדש במדיניות אחרת בהמשך התהליך, או לשלוח את אובייקט הבקשה החדש לשירות חיצוני באמצעות מדיניות ServiceCallout.
בטבלה הבאה מתוארים המאפיינים של <AssignTo>:
| מאפיין | תיאור | חובה? | סוג |
|---|---|---|---|
createNew |
קובעת אם המדיניות הזו יוצרת הודעה חדשה כשמגדירים ערכים. אם הערך הוא true, המדיניות יוצרת משתנה חדש מהסוג שצוין על ידי אם הערך הוא false, המדיניות מגיבה באחת משתי דרכים:
אם לא מציינים את
|
אופציונלי | בוליאני |
transport |
מציין את סוג התעבורה של סוג ההודעה של הבקשה או התגובה. ערך ברירת המחדל הוא 'http' (הערך הנתמך היחיד). |
אופציונלי | מחרוזת |
type |
מציין את סוג ההודעה החדשה, אם הערך של createNew הוא true. הערכים התקינים הם request או response.
אם משמיטים את המאפיין הזה, Edge יוצר בקשה או תגובה, בהתאם למיקום שבו המדיניות הזו מופעלת בתהליך. |
אופציונלי | מחרוזת |
<AssignVariable>
הפונקציה מקצה ערך למשתנה של זרימת נתונים. אם משתנה הזרימה לא קיים, הפונקציה <AssignVariable> יוצרת אותו.
| ערך ברירת המחדל | לא רלוונטי |
| חובה? | אופציונלי |
| סוג | סוג מורכב |
| רכיב אב |
<AssignMessage>
|
| רכיבי צאצא |
<Name> (חובה)<Ref><Template><Value> |
הערך שאתם מקצים למשתנה של זרימת העבודה יכול להיות אחד מהערכים הבאים:
- מחרוזת מילולית: משתמשים ברכיב המשני
<Value>כדי לציין ערך מחרוזת מילולית למשתנה של זרימת העבודה. - משתנה של זרימת נתונים: משתמשים ברכיב המשני
<Ref>כדי לציין את הערך של משתנה קיים של זרימת נתונים עבור משתנה היעד של זרימת הנתונים. רשימה מלאה של משתני זרימה שאפשר להשתמש בהם כמקור זמינה במאמר חומר עזר בנושא משתני זרימה. - תבנית הודעה: משתמשים ברכיב המשני
<Template>כדי לציין תבנית הודעה לאינטרפולציה, כדי לקבל את הערך שיוצב במשתנה היעד של הזרימה.
רכיב <AssignVariable> משתמש בתחביר הבא:
תחביר
<AssignMessage continueOnError="[false|true]" enabled="[true|false]" > na<me="polic>y_nam<e&qu>ot; Assign<Varia>ble < >Namevariable_na<me/N>ame < Refso>urce_variable/Re<f Tem>platemessage<_template/Template or Te><mplate re>f=<9;tem>plate_variable<'/>Tem<plate Value>v<ariable_value/>Value /AssignVariable /AssignMessage
משתמשים ברכיב <Ref> כדי לציין את משתנה המקור. אם המשתנה שאליו מתבצעת ההפניה באמצעות <Ref> לא נגיש, Edge משתמש בערך שצוין ברכיב <Value>. אם מגדירים את
<Template>, הוא מקבל עדיפות על פני רכיבי הצאצא האחרים.
דוגמה 1
בדוגמה הבאה מוגדר הערך של משתנה חדש, myvar, כערך המילולי '42':
<AssignMessage name="assignvariab>le-<1" Assi>gnVar<iabl>e < Name>myvar</Name> < Val>ue4<2/Value /Assi>g<nVariable /Ass>ignMessage
דוגמה 2
בדוגמה הבאה מוקצה הערך של משתנה הזרימה
request.header.user-agent למשתנה זרימת היעד myvar
והערך של פרמטר השאילתה country מוקצה למשתנה זרימת היעד
Country:
<AssignMessage name="assignvariab>le-<2" Assi>gnVar<iabl>e < Name>myvar</Na>me Refrequest.header.<user>-agen<t/Ref> ValueE<rrorOn>Cop<y/Value /Assi>gnV<ariable Assi>gnVar<iabl>e N<ameCo>untry</Na>me Refrequest.querypar<am.c>ountr<y/Ref> ValueE<rrorOn>Cop<y/Value /Assi>g<nVariable /Ass>ignMessage
אם אחת מההקצאות נכשלת, Edge מקצה במקום זאת את הערך ErrorOnCopy למשתנה היעד של זרימת הנתונים.
אם משתני הזרימה myvar או Country לא קיימים, המערכת של <AssignVariable> יוצרת אותם.
דוגמה 3
בדוגמה הבאה נעשה שימוש ברכיב הצאצא <Template> כדי לשרשר שתי משתני הקשר עם מחרוזת מילולית (מקף) ביניהם:
<AssignMessage name='AV-via-templat>e-1<' IgnoreUnresolvedV>ariab<lesfalse/IgnoreUnresolvedV>ari<ables Assign>Varia<ble<>/span> Namemy_destination_<varia>ble/N<ame > Value<BADDBE>EF/Va<lue >Template{system.uuid}-{me<ssageid}/>Tem<plate /Assign>V<ariable /Assig>nMessage
שימוש נפוץ ב-<AssignVariable> הוא להגדרת ערך ברירת מחדל לפרמטר של שאילתה, לכותרת או לערך אחר שאפשר להעביר עם הבקשה. כדי לעשות את זה, משתמשים בשילוב של רכיבי הצאצא <Ref> ו-<Value>. מידע נוסף זמין בדוגמאות ל-<Ref>.
<Name> (ילד של <AssignVariable>)
מציין את השם של משתנה היעד של זרימת הנתונים (למשל, המשתנה שהערך שלו מוגדר על ידי מדיניות AssignMessage). אם המשתנה שצוין ב-<AssignVariable> לא קיים, המדיניות יוצרת משתנה בשם הזה.
| ערך ברירת המחדל | לא רלוונטי |
| חובה? | חובה |
| סוג | מחרוזת |
| רכיב אב |
<AssignVariable>
|
| רכיבי צאצא | ללא |
רכיב <Name> משתמש בתחביר הבא:
תחביר
<AssignMessage continueOnError="[false|true]" enabled="[true|false]" > na<me="polic>y_nam<e&qu>ot; Assign<Varia>ble< Namevariab>l<e_name/Name >/AssignVariable /AssignMessage
דוגמה 1
בדוגמה הבאה, משתנה היעד הוא myvar, והוא מוגדר לערך המילולי '42':
<AssignMessage name="assignvariab>le-<1" Assi>gnVar<iabl>e < Name>myvar</Name> < Val>ue4<2/Value /Assi>g<nVariable /Ass>ignMessage
אם myvar לא קיים, הפונקציה <AssignVariable> יוצרת אותו.
<Ref> (ילד של <AssignVariable>)
מציין את המקור של ההקצאה כמשתנה של זרימת העבודה. משתנה הזרימה יכול להיות אחד ממשתני הזרימה המוגדרים מראש (כפי שמפורט בהפניה למשתני זרימה), או משתנה זרימה מותאם אישית שיצרתם.
הערך של <Ref> תמיד מתפרש כמשתנה של זרימת נתונים. אי אפשר לציין מחרוזת מילולית כערך. כדי להקצות ערך מחרוזת מילולי, צריך להשתמש במקום זאת ברכיב <Value>.
| ערך ברירת המחדל | לא רלוונטי |
| חובה? | אופציונלי |
| סוג | מחרוזת |
| רכיב אב |
<AssignVariable>
|
| רכיבי צאצא | ללא |
כשמציינים משתנה של זרימת נתונים באמצעות <Ref>, לא כוללים את הסוגריים המסולסלים {} שמשמשים בדרך כלל להפניה למשתנה של זרימת נתונים. לדוגמה, כדי להגדיר את הערך של המשתנה החדש לערך של המשתנה client.host flow:
Do this (no brackets): <Ref>client.host</Ref> Do NOT do this (brackets): <Ref>{client.host}</Ref>
כדי להגדיר ערך ברירת מחדל למשתנה של זרימת היעד, משתמשים ב-<Value>
בשילוב עם <Ref>. אם משתנה הזרימה שצוין על ידי
<Ref> לא קיים, אי אפשר לקרוא אותו או שהוא null, Edge מקצה במקומו את הערך של <Value> למשתנה זרימת היעד.
רכיב <Ref> משתמש בתחביר הבא:
תחביר
<AssignMessage continueOnError="[false|true]" enabled="[true|false]" > na<me="polic>y_nam<e&qu>ot; Assign<Varia>ble < >Namevariable_na<me/N>ame< Refsource_>v<ariable/Ref >/AssignVariable /AssignMessage
דוגמה 1
בדוגמה הבאה מוקצה הערך של משתנה הזרימה
request.header.user-agent למשתנה זרימת היעד myvar, והערך של פרמטר השאילתה country מוקצה למשתנה Country:
<AssignMessage name="assignvariab>le-<4" Assi>gnVar<iabl>e < Name>myvar</Na>me Refrequest.header.<user>-ag<ent/Ref /Assi>gnV<ariable Assi>gnVar<iabl>e N<ameCo>untry</Na>me Refrequest.querypar<am.c>oun<try/Ref /Assi>g<nVariable /Ass>ignMessage
בדוגמה הזו, לא הוגדרה ב-Edge ברירת מחדל (או ערך חלופי) לאף אחת מהמטלות.
דוגמה 2
בדוגמה הבאה, הערך של משתנה הזרימה request.header.user-agent מוקצה למשתנה זרימת היעד myvar, והערך של פרמטר השאילתה country מוקצה למשתנה Country:
<AssignMessage name="assignvariab>le-<2" Assi>gnVar<iabl>e < Name>myvar</Na>me Refrequest.header.<user>-agen<t/Ref> ValueE<rrorOn>Cop<y/Value /Assi>gnV<ariable Assi>gnVar<iabl>e N<ameCo>untry</Na>me Refrequest.querypar<am.c>ountr<y/Ref> ValueE<rrorOn>Cop<y/Value /Assi>g<nVariable /Ass>ignMessage
בדוגמה הזו, אם הערכים של request.header.user-agent משתנה הזרימה או של Country פרמטר השאילתה הם null, לא ניתנים לקריאה או פגומים, Edge מקצה את הערך ErrorOnCopy למשתנים החדשים.
דוגמה 3
מקרה שימוש נפוץ ב-<AssignVariable> הוא הגדרת ערך ברירת המחדל של פרמטר שאילתה, כותרת או ערך אחר שאפשר להעביר עם הבקשה. לדוגמה, אתם יוצרים שרת proxy של API למזג אוויר, שבו הבקשה מקבלת פרמטר שאילתה יחיד בשם w. הפרמטר הזה מכיל את מזהה העיר שרוצים לדעת את מזג האוויר שלה. כתובת ה-URL של הבקשה היא מהצורה:
http://myCO.com/v1/weather/forecastrss?w=city_ID
כדי להגדיר ערך ברירת מחדל ל-w, יוצרים מדיניות AssignMessage כמו בדוגמה הבאה:
<AssignMessage continueOnError="false" enabled="true" nam>e=&<quot;assignvariable-3" AssignTo createNew="fals>e&q<uot; transport="http>" <type="request"/ > I<gnoreUnresolve>dVari<able>strue /IgnoreUnres<olved>Varia<ble>s AssignVariable < N>amere<quest>.querypa<ram.w/>Nam<e Refreques>t<.queryparam.w/>Ref Value12797282/Value /AssignVariable /AssignMessage
בדוגמה הזו, <AssignVariable> מקבל את הערך של request.queryparam.w ומקצה אותו לעצמו. אם משתנה הזרימה הוא null, כלומר פרמטר השאילתה w הושמט מהבקשה, בדוגמה הזו נעשה שימוש בערך ברירת המחדל מהרכיב <Value>. לכן, אפשר לשלוח בקשה ל-API proxy הזה בלי פרמטר השאילתה w:
http://myCO.com/v1/weather/forecastrss
…ועדיין להחזיר תוצאה תקינה מ-API Proxy.
בניגוד לשימוש ב-<Value>, הערך של <Ref> חייב להיות משתנה של זרימת נתונים, כמו מאפיין של אובייקט request, response או target. הערך יכול להיות גם משתנה מותאם אישית של זרימת העבודה שיצרתם.
אם מציינים משתנה של זרימה שלא קיים עבור הערך של <Ref>, והערך של <IgnoreUnresolvedVariables> הוא true, Edge יחזיר שגיאה.
<Template> (ילד של <AssignVariable>)
מציינים תבנית הודעה. תבנית של הודעה מאפשרת לבצע החלפה של מחרוזות משתנות כשהמדיניות מופעלת, ויכולה לשלב מחרוזות מילוליות עם שמות משתנים שמוקפים בסוגריים מסולסלים. בנוסף, תבניות של הודעות תומכות ב פונקציות כמו ביטול בריחה והמרת אותיות רישיות לאותיות קטנות ולהפך.
משתמשים במאפיין ref כדי לציין משתנה של זרימה שבו הערך של המשתנה הוא תבנית הודעה. לדוגמה, אפשר לאחסן תבנית הודעה כמאפיין מותאם אישית באפליקציית פיתוח. כש-Edge מזהה את אפליקציית הפיתוח אחרי שהוא מאמת את מפתח ה-API או את אסימון האבטחה (באמצעות מדיניות נוספת), רכיב ה-<AssignVariable> יכול להשתמש בתבנית ההודעה מתוך המאפיין המותאם אישית של האפליקציה, שזמין כמשתנה של זרימת נתונים ממדיניות האבטחה.
| ערך ברירת המחדל | לא רלוונטי |
| חובה? | אופציונלי |
| סוג | מחרוזת |
| רכיב אב |
<AssignVariable>
|
| רכיבי צאצא | ללא |
רכיב <Template> משתמש בתחביר הבא:
תחביר
<AssignMessage continueOnError="[false|true]" enabled="[true|false]" > na<me="polic>y_nam<e" > AssignVariabl<e Tem>platemessage<_template/Template or Te><mplate re>f=&<#39;template_va>r<iable'/Tem>plate /AssignVariable /AssignMessage
דוגמה 1
בדוגמה הבאה נעשה שימוש בתחביר של תבניות הודעות כדי לשרשר שתי משתני הקשר עם מחרוזת מילולית (מקף) ביניהם:
<AssignMessage name='AV-via-templat>e-1<' IgnoreUnresolvedV>ariab<lesfalse/IgnoreUnresolvedV>ari<ables Assign>Varia<ble<>/span> Namemy_destination_<varia>ble/N<ame > Value<BADDBE>EF/Va<lue >Template{system.uuid}-{me<ssageid}/>Tem<plate /Assign>V<ariable /Assig>nMessage
דוגמה 2
בדוגמה הבאה מוגדר משתנה של זרימה, שבו הערך של המשתנה הוא תבנית הודעה שהוגדרה מראש. אפשר להשתמש באפשרות הזו אם רוצים להוסיף תבנית מוגדרת מראש בזמן הריצה בלי לשנות את המדיניות:
<AssignMessage name='AV-via-template-indirec>tly&#<39; IgnoreUnresolvedV>ariab<lesfalse/IgnoreUnresolvedV>ari<ables Assign>Varia<ble<>/span> Namemy_destination_<varia>ble/N<ame > Value<BADDBE>EF/Va<lue Template ref='my_templat>e_v<ariable'/ > </AssignVariabl>e /AssignMessage
דוגמה 3
בדוגמה הבאה מצוינים משתנה של זרימה וערך טקסט. במקרה כזה, אם המשתנה שאליו מתבצעת ההפניה הוא לא null, הערך הזה ישמש כתבנית. אם הערך שאליו יש הפניה הוא null, המערכת משתמשת בערך הטקסט (במקרה הזה, {system.uuid}-{messageid}) כתבנית. התבנית הזו שימושית כדי לספק ערך של 'שינוי ברירת מחדל', במקרים שבהם רוצים לשנות את ברירת המחדל של התבנית (חלק הטקסט) עם ערכים שמוגדרים באופן דינמי. לדוגמה, משפט מותנה יכול לאחזר ערך ממפת מפתח/ערך ולהגדיר את המשתנה שאליו מתייחסים כערך הזה:
<AssignMessage name='AV-template-with-fallb>ack<' IgnoreUnresolvedV>ariab<lesfalse/IgnoreUnresolvedV>ari<ables Assign>Varia<ble<>/span> Namemy_destination_<varia>ble/N<ame > Value<BADDBE>EF/Va<lue Template ref='>my_variable'{system.u<uid}-{mes>sag<eid}/Template > </AssignVariabl>e /AssignMessage
<Value> (ילד של <AssignVariable>)
הערך של משתנה היעד של הזרימה שמוגדר באמצעות <AssignVariable>. הערך תמיד מתפרש כמחרוזת ליטרלית. אי אפשר להשתמש במשתנה של זרימת נתונים כערך, גם אם מקיפים את הערך בסוגריים מסולסלים ({}). כדי להשתמש במשתנה של זרימת נתונים, צריך להשתמש ב-<Ref> במקום זאת.
| ערך ברירת המחדל | לא רלוונטי |
| חובה? | אופציונלי |
| סוג | מחרוזת |
| רכיב אב |
<AssignVariable>
|
| רכיבי צאצא | ללא |
כשמשתמשים בו בשילוב עם הרכיב <Ref>, <Value>
פועל כערך ברירת המחדל (או כערך חלופי). אם לא מציינים את <Ref>, אם אי אפשר לפתור את <Ref> או אם הוא null, המערכת משתמשת בערך של <Value>.
רכיב <Value> משתמש בתחביר הבא:
תחביר
<AssignMessage continueOnError="[false|true]" enabled="[true|false]" > na<me="polic>y_nam<e&qu>ot; Assign<Varia>ble < Na>mevariable_nam<e/Name> < Valuevariable>_<value/Value >/AssignVariable /AssignMessage
דוגמה 1
בדוגמה הבאה מוגדר הערך של משתנה היעד של הזרימה, myvar,
לערך המילולי '42':
<AssignMessage name="assignvariab>le-<1" Assi>gnVar<iabl>e < Name>myvar</Name> < Val>ue4<2/Value /Assi>g<nVariable /Ass>ignMessage
דוגמה 2
בדוגמה הבאה מוקצה הערך של משתנה הזרימה
request.header.user-agent למשתנה הזרימה myvar, והערך
של פרמטר השאילתה country מוקצה למשתנה Country:
<AssignMessage name="assignvariab>le-<2" Assi>gnVar<iabl>e < Name>myvar</Na>me Refrequest.header.<user>-agen<t/Ref> ValueE<rrorOn>Cop<y/Value /Assi>gnV<ariable Assi>gnVar<iabl>e N<ameCo>untry</Na>me Refrequest.querypar<am.c>ountr<y/Ref> ValueE<rrorOn>Cop<y/Value /Assi>g<nVariable /Ass>ignMessage
אם אחת מההקצאות נכשלת, במקום זאת, <AssignVariable> מקצה את הערך ErrorOnCopy למשתנה היעד של הזרימה.
<Copy>
מעתיק ערכים מהההודעה שצוינה במאפיין source
אל ההודעה שצוינה ברכיב <AssignTo>. אם לא מציינים יעד באמצעות <AssignTo>, המדיניות הזו מעתיקה את הערכים לבקשה או לתשובה, בהתאם למיקום שבו המדיניות הזו מופעלת בתהליך.
| ערך ברירת המחדל | לא רלוונטי |
| חובה? | אופציונלי |
| סוג | מחרוזת |
| רכיב אב |
<AssignMessage>
|
| רכיבי צאצא |
<FormParams><Headers><Path><Payload><QueryParams><ReasonPhrase><StatusCode><Verb><Version> |
אם לא מציינים רכיבי צאצא מתחת לרכיב <Copy>, כל החלקים של הודעת המקור שצוינה יועתקו.
רכיב <Copy> משתמש בתחביר הבא:
תחביר
<AssignMessage
continueOnError="[false|true]"
enabled="[true|false]"
> name<="policy_name"
Co>py so<urce="[request|response]&qu<ot;
!--> Can also <be an empt>y array< (FormParams/) -->
FormP>arams
For<mParam nam>e="formpar<am_name&quo>t;for<mparam_value/FormParam
...<
/Fo>rmParams
< !-- >Can als<o be an empty array (Head>ers/) --><
He>aders
Hea<der name>=&quo<t;he>ader_name&qu<ot;he>ader_<value/H>eader
<...
>/Head<ers
Path[false|true]/Path
< Payload[fa>lse|true]/<Payload
> !-- Ca<n also be an empty array (QueryPa>rams/) -->
< QueryPara>ms
QueryP<aram name=&q>uot;q<ueryparam_na>me"quer<yparam_value/>Query<Param
> ...
/Q<ueryParams<>/span>
R<easo>nPhrase[fals<e|tru>e]/Re<asonPhr>ase
Stat<usCode[f>als<e|tru>e]/<StatusCode
Verb[false|true]/Verb<
> Version[f>als<e|true]/Version
/Copy
!-- Used as the destination for the Copy values --
A>ssignTo createNew="[<true|fals>e<]" transp>ort="http"
type="[request|response]"destination_variable_name/AssignTo
/AssignMessage
דוגמה 1
בדוגמה הבאה מועתקת כותרת, שלושה פרמטרים של טופס, הנתיב וכל פרמטרים השאילתה מההודעה request לבקשה חדשה בהתאמה אישית בשם newRequest:
<AssignMessage name="AM-co>py-<1" AssignTo createNew="true" transport=&>quot;http&<quot; typ>e=&<quot;request"new>Reque<st/Assi>gnTo <Copy source="request&qu>ot; < Heade>rs < Header> name=&<quot;Header_Name_1"/ /Head>ers < FormParams FormParam name=&q>uot;For<m_Param_Name_1"/ FormPar>am na<me="Fo>rm_Pa<ram_>Name<_2&qu>ot;/ < FormPa>ram< name>=<"Form_Par>am_Name_3"/ /FormParams Pathtrue/Path QueryParams/ /Copy /AssignMessage
מכיוון שרכיבים כמו <Payload> ו-<Verb> לא קיימים, המדיניות לא מעתיקה את החלקים האלה של ההודעה.
דוגמה 2
בדוגמה הבאה, קודם מסירים את כל מה שיש בהודעה הקיימת response, ואז מעתיקים את כל הערכים מהודעה אחרת שנקראת secondResponse אל ההודעה response:
<AssignMessage name='AM-Copy-Respo>nse<' AssignTo createNew="false" transport=&quo>t;http&q<uot; type>=&q<uot;response"response/AssignTo !>-- <first r>emo<ve any existing values -- Remove/ !-- then copy eve>ryt<hing from the designated mess>a<ge -- Copy s>ource="secondResponse"/ /AssignMessage
לרכיב <Copy> יש מאפיין אחד:
| מאפיין | תיאור | חובה? | סוג |
|---|---|---|---|
| source |
מציין את אובייקט המקור של ההעתקה.
|
אופציונלי | מחרוזת |
<FormParams> (ילד של <Copy>)
מעתין פרמטרים של טופס מהבקשה שצוינה על ידי מאפיין source של רכיב <Copy> לבקשה שצוינה על ידי רכיב <AssignTo>. לרכיב הזה אין השפעה על התגובה.
| ערך ברירת המחדל | לא רלוונטי |
| חובה? | אופציונלי |
| סוג | מערך של רכיבי <FormParam> או מערך ריק |
| רכיב אב |
<Copy>
|
| רכיבי צאצא |
<FormParam> |
רכיב <FormParams> משתמש בתחביר הבא:
תחביר
<AssignMessage continueOnError="[false|true]" enabled="[true|false]" > na<me="policy_name" Co>py so<urce="[request|response]&qu<ot; !--> Can also <be an empt>y array< (FormParams/) --> FormP>arams For<mParam nam>e="formpar<am_name&quo>t;f<ormpa>r<am_value/FormP>aram ... /FormParams /Copy /AssignMessage
דוגמה 1
בדוגמה הבאה מועתק פרמטר טופס יחיד מהבקשה אל הבקשה המותאמת אישית MyCustomRequest:
<AssignMessage name="copy-formpara>ms-<1" Copy source>=&quo<t;request&>quot; < FormParams FormPa>ram name="par<amName&quo>t;For<m param val>ue <1/For>mPa<ram /FormParams /Copy AssignTo createNew="tr>ue" transp<ort=">;<http" typ>e="request"MyCustomRequest/AssignTo /AssignMessage
דוגמה 2
בדוגמה הבאה מועתקים כל פרמטרי הטופס לבקשה המותאמת אישית MyCustomRequest:
<AssignMessage name="copy-formpara>ms-<2" Copy source>=&quo<t;request&q>uot<; > Fo<rmParams/ /Copy AssignTo createNew="true" t>ransport="<http">;< type="re>quest"MyCustomRequest/AssignTo /AssignMessage
דוגמה 3
בדוגמה הבאה מועתקים שלושה פרמטרים של טופס לבקשה המותאמת אישית MyCustomRequest:
<AssignMessage name="copy-formpara>ms-<3" Copy source>=&quo<t;request&>quot; < FormParams FormPara>m name=<"paramName1"/ > FormP<aram name="paramName2&q>uot;/< Form>Par<am na>me=<"paramName3"/ /FormParams /Copy AssignT>o createNew=&qu<ot;true&q>u<ot; transport=>"http" type="request"MyCustomRequest/AssignTo /AssignMessage
דוגמה 4
אם יש כמה פרמטרים של טופס עם אותו שם, משתמשים בתחביר הבא:
<AssignMessage name="copy-formpara>ms-<4" Copy source>=&quo<t;request&>quot; < FormParams >FormPar<am name="f1&quo>t;/ < FormParam name=&quo>t;f2&<quot;/ > F<ormPa>ram< name="f3.2"/ /FormParams /Copy AssignT>o createNew=&qu<ot;true&q>u<ot; transport=>"http" type="request"MyCustomRequest/AssignTo /AssignMessage
בדוגמה הזו, הפונקציה מעתיקה את הערכים f1, f2 ואת הערך השני של f3. אם למאפיין f3 יש רק ערך אחד, הוא לא מועתק.
אפשר להשתמש ב-<FormParams> רק אם מתקיימים הקריטריונים הבאים:
- פועל HTTP: POST
- סוג ההודעה: תגובה
- אחת (או שתי) מהאפשרויות הבאות:
- נתוני טופס: מוגדר לערך כלשהו או ל-"" (המחרוזת הריקה). לדוגמה, עם
curl, מוסיפים-d ""לבקשה. - הכותרת
Content-Length: הערך שמוגדר הוא 0 (אם אין נתונים בבקשה המקורית, אחרת, האורך הנוכחי). לדוגמה, אם רוצים להוסיף את הפקודהcurladd-H "Content-Length: 0"לבקשה.
- נתוני טופס: מוגדר לערך כלשהו או ל-"" (המחרוזת הריקה). לדוגמה, עם
כשמעתיקים את <FormParams>, <Copy> מגדיר את Content-Type של ההודעה ל-application/x-www-form-urlencoded לפני שליחת ההודעה לשירות היעד.
<Headers> (ילד של <Copy>)
מעתין כותרות HTTP מהבקשה או מהודעת התגובה שצוינו על ידי מאפיין source של אלמנט <Copy> אל הבקשה או הודעת התגובה שצוינו על ידי אלמנט <AssignTo>.
| ערך ברירת המחדל | לא רלוונטי |
| חובה? | אופציונלי |
| סוג | מערך של רכיבי <Header> או מערך ריק |
| רכיב אב |
<Copy>
|
| רכיבי צאצא |
<Header> |
רכיב <Headers> משתמש בתחביר הבא:
תחביר
<AssignMessage continueOnError="[false|true]" enabled="[true|false]" > na<me="policy_name" Co>py so<urce="[request|response]&qu<ot; >!-- Can al<so be a>n empty< array (Headers/) --> > Headers < H>eader name=&quo<t;header>_na<me&qu>o<t;header_value>/Header ... /Headers /Copy /AssignMessage
דוגמה 1
בדוגמה הבאה מועתקת הכותרת user-agent מהבקשה לאובייקט הבקשה המותאם אישית החדש:
<AssignMessage name="copy-heade>rs-<1" Copy source>=&quo<t;reque>st"<; Headers Heade>r nam<e=">use<r-age>nt&<quot;/ /Headers /Copy AssignTo createNew="tr>ue" transp<ort=">;<http" typ>e="request"MyCustomRequest/AssignTo /AssignMessage
דוגמה 2
כדי להעתיק את כל הכותרות, משתמשים ברכיב <Headers> ריק, כמו בדוגמה הבאה:
<AssignMessage name="copy-heade>rs-<2" Copy source>=&quo<t;reques>t&q<uot;<>/span> < Headers/ /Copy AssignTo createNew="true" t>ransport="<http">;< type="re>quest"MyCustomRequest/AssignTo /AssignMessage
דוגמה 3
אם יש כמה כותרות עם אותו שם, צריך להשתמש בתחביר הבא:
<AssignMessage name="copy-heade>rs-<3" Copy source>=&quo<t;reque>st"<; Headers > Head<er name="h1&>quot;/ < Header name=&>quot;<h2">/ < >Hea<der name="h3.2"/ /Headers /Copy AssignT>o createNew=&qu<ot;true&q>u<ot; transport=>"http" type="request"MyCustomRequest/AssignTo /AssignMessage
בדוגמה הזו, הפונקציה מעתיקה את הערכים h1, h2 ואת הערך השני של h3. אם למאפיין h3 יש רק ערך אחד, הוא לא מועתק.
<Path> (ילד של <Copy>)
הפונקציה קובעת אם להעתיק את הנתיב מבקשת המקור לבקשת היעד. לרכיב הזה אין השפעה על התשובה.
אם הערך הוא True, המדיניות מעתיקה את הנתיב מה הודעת הבקשה שצוינה על ידי המאפיין source של הרכיב <Copy> אל הודעת הבקשה שצוינה על ידי הרכיב <AssignTo>.
| ערך ברירת המחדל | לא נכון |
| חובה? | אופציונלי |
| סוג | בוליאני |
| רכיב אב |
<Copy>
|
| רכיבי צאצא | ללא |
רכיב <Path> משתמש בתחביר הבא:
תחביר
<AssignMessage
continueOnError="[false|true]"
enabled="[true|false]"
> na<me="policy_name"
Co>py so<urce>="[requ<est|r>esp<onse]>&<quot;
Path>[false|true]/Path
/Copy
/AssignMessageדוגמה 1
בדוגמה הבאה מצוין שמדיניות AssignMessage צריכה להעתיק את הנתיב מבקשת המקור לאובייקט הבקשה החדש והמותאם אישית:
<AssignMessage name="copy-pa>th-<1" Copy source>=&quo<t;re>ques<t&quo>t; < P>ath<true/Path /Copy AssignTo createNew="true" t>ransport="<http">;< type="re>quest"MyCustomRequest/AssignTo /AssignMessage
אפשר להשתמש ב-<Path> רק אם מתקיימים הקריטריונים הבאים:
- סוג ההודעה: בקשה
<Payload> (ילד של <Copy>)
המדיניות הזו קובעת אם מטען הייעוד צריך להיות מועתק מהמקור ליעד. המקור והיעד יכולים להיות בקשות או תגובות.
אם הערך הוא true, המדיניות מעתיקה את מטען הייעודי מהההודעה שצוינה על ידי המאפיין source של הרכיב <Copy> אל ההודעה שצוינה על ידי הרכיב <AssignTo>.
| ערך ברירת המחדל | לא נכון |
| חובה? | אופציונלי |
| סוג | בוליאני |
| רכיב אב |
<Copy>
|
| רכיבי צאצא | ללא |
רכיב <Payload> משתמש בתחביר הבא:
תחביר
<AssignMessage continueOnError="[false|true]" enabled="[true|false]" > na<me="policy_name" Co>py so<urce=&q>uot;[request<|respons>e]&<quot;> < Payload[fa>lse|true]/Payload /Copy /AssignMessage
דוגמה 1
בדוגמה הבאה, הערך של <Payload> מוגדר כ-true, כך שמטען הייעודי (payload) של הבקשה מועתק מהבקשה לתגובה:
<AssignMessage name="AM-copy-paylo>ad-<1" Copy source>=&quo<t;reque>st&q<uot; > Pa<yload>tru<e/Payloa>d /Cop<y Assig>n<Toresponse/Ass>ignTo /AssignMessage
<QueryParams> (ילד של <Copy>)
מעתיק פרמטרים של מחרוזת שאילתה מהבקשה שצוינה על ידי המאפיין source של הרכיב <Copy> אל הבקשה שצוינה על ידי הרכיב <AssignTo>. לרכיב הזה אין השפעה על התשובה.
| ערך ברירת המחדל | לא רלוונטי |
| חובה? | אופציונלי |
| סוג | מערך של רכיבי <QueryParam> או מערך ריק |
| רכיב אב |
<QueryParam>
|
| רכיבי צאצא | ללא |
רכיב <QueryParams> משתמש בתחביר הבא:
תחביר
<AssignMessage continueOnError="[false|true]" enabled="[true|false]" > na<me="policy_name" Co>py so<urce="[request|response]&qu<ot; !-- >Can also b<e an empty >array (<QueryParams/) --> QueryPar>ams QueryP<aram name=&>quot;queryparam<_name"q>uer<ypara>m<_value/QueryPa>ram ... /QueryParams /Copy /AssignMessage
דוגמה 1
בדוגמה הבאה מועתק פרמטר השאילתה my_param מהבקשה לאובייקט בקשה מותאם אישית חדש:
<AssignMessage name="copy-querypara>ms-<1" Copy source>=&quo<t;request&q>uot; < QueryParams QueryPa>ram n<ame="my>_pa<ram&q>uot<;/ /QueryParams /Copy AssignTo createNew="tr>ue" transp<ort=">;<http" typ>e="request"MyCustomRequest/AssignTo /AssignMessage
דוגמה 2
בדוגמה הבאה מועתקים כל פרמטרי השאילתה מהבקשה לאובייקט בקשה מותאם אישית חדש:
<AssignMessage name="copy-querypara>ms-<2" Copy source>=&quo<t;request&qu>ot;< >Que<ryParams/ /Copy AssignTo createNew="true" t>ransport="<http">;< type="re>quest"MyCustomRequest/AssignTo /AssignMessage
דוגמה 3
אם יש כמה פרמטרים של שאילתה עם אותו שם, צריך להשתמש בתחביר הבא:
<AssignMessage name="copy-querypara>ms-<3" Copy source>=&quo<t;request&q>uot; < QueryParams Qu>eryPara<m name="qp1">/ < QueryParam name="q>p2&qu<ot;/ Q>uer<yPara>m n<ame="qp3.2"/ /QueryParams /Copy AssignT>o createNew=&qu<ot;true&q>u<ot; transport=>"http" type="request"MyCustomRequest/AssignTo /AssignMessage
בדוגמה הזו, הפונקציה מעתיקה את הערכים qp1, qp2 ואת הערך השני של qp3. אם ל-qp3 יש רק ערך אחד, הוא לא מועתק.
אפשר להשתמש ב-<QueryParams> רק אם מתקיימים הקריטריונים הבאים:
- פועל HTTP: GET
- סוג ההודעה: בקשה
<ReasonPhrase> (ילד של <Copy>)
קובעת אם צריך להעתיק את משפט הסיבה מתגובת המקור לתגובת היעד. לרכיב הזה אין השפעה על בקשה.
אם הערך הוא True, המדיניות הזו מעתיקה את ReasonPhrase מהתגובה שצוינה על ידי המאפיין source של הרכיב <Copy> אל התגובה שצוינה על ידי הרכיב <AssignTo>.
| ערך ברירת המחדל | לא נכון |
| חובה? | אופציונלי |
| סוג | בוליאני |
| רכיב אב |
<Copy>
|
| רכיבי צאצא | ללא |
רכיב <ReasonPhrase> משתמש בתחביר הבא:
תחביר
<AssignMessage
continueOnError="[false|true]"
enabled="[true|false]"
> na<me="policy_name"
Co>py so<urce="[>request|resp<onse]"
> <Reaso>n<Phrase[false|t>rue]/ReasonPhrase
/Copy
/AssignMessageדוגמה 1
בדוגמה הבאה, הערך של <ReasonPhrase> מוגדר ל-true. עם רכיב המקור <AssignTo> כפי שצוין, הפעולה הזו גורמת ל-<Copy> להעתיק את משפט הסיבה מהודעת התגובה שצוינה לאובייקט response:
<AssignMessage name="AM-copy-reasonphra>se-<1" Copy source="serviceC>allou<tResponse&qu>ot; < ReasonPhr>ase<true/>Rea<sonPhras>e /Cop<y Assig>n<Toresponse/Ass>ignTo /AssignMessage
אפשר להשתמש ב-<ReasonPhrase> רק אם הודעות המקור והיעד הן מסוג תגובה.
<StatusCode> (ילד של <Copy>)
ההגדרה קובעת אם קוד הסטטוס מועתק מהתגובה של המקור לתגובה של היעד. לרכיב הזה אין השפעה על בקשה.
אם הערך הוא true, המדיניות מעתיקה את קוד הסטטוס מה הודעת התגובה שצוינה על ידי רכיב <Copy>, מאפיין source להודעת התגובה שצוינה על ידי רכיב <AssignTo>.
| ערך ברירת המחדל | לא נכון |
| חובה? | אופציונלי |
| סוג | בוליאני |
| רכיב אב |
<Copy>
|
| רכיבי צאצא | ללא |
רכיב <StatusCode> משתמש בתחביר הבא:
תחביר
<AssignMessage
continueOnError="[false|true]"
enabled="[true|false]"
> na<me="policy_name"
Co>py so<urce=">;[request|re<sponse]&quo>t;
< S>t<atusCode[false>|true]/StatusCode
/Copy
/AssignMessageדוגמה 1
בדוגמה הבאה, הערך של <StatusCode> מוגדר כ-true, ולכן קוד הסטטוס מועתק מאובייקט התגובה שמוגדר כברירת מחדל לאובייקט תגובה חדש ומותאם אישית:
<AssignMessage name="copy-statusco>de-<1" Copy source=>"<;response&>quot<; Statu>sCo<detru>e/S<tatusCode /Copy AssignTo createNew="true" tr>ansport="ht<tp" >t<ype="resp>onse"MyCustomResponse/AssignTo /AssignMessage
אפשר להשתמש ב-<StatusCode> רק אם הודעות המקור והיעד הן מסוג תגובה.
אחד מהשימושים הנפוצים ב-<StatusCode> הוא הגדרת קוד סטטוס של תגובת שרת ה-proxy לערך שונה מזה שהתקבל מהיעד.
<Verb> (ילד של <Copy>)
הפונקציה קובעת אם פועל ה-HTTP מועתק מבקשת המקור לבקשת היעד. לרכיב הזה אין השפעה על התשובה.
אם הערך הוא true, הפועל שנמצא במאפיין source של הרכיב <Copy> מועתק לבקשה שצוינה ברכיב <AssignTo>.
| ערך ברירת המחדל | לא נכון |
| חובה? | אופציונלי |
| סוג | בוליאני |
| רכיב אב |
<Copy>
|
| רכיבי צאצא | ללא |
רכיב <Verb> משתמש בתחביר הבא:
תחביר
<AssignMessage
continueOnError="[false|true]"
enabled="[true|false]"
> na<me="policy_name"
Co>py so<urce>="[requ<est|r>esp<onse]>&<quot;
Verb>[false|true]/Verb
/Copy
/AssignMessageדוגמה 1
בדוגמה הבאה, הערך של <Verb> מוגדר כ-true, ולכן הפועל מועתק מהבקשה שמוגדרת כברירת מחדל לבקשה חדשה בהתאמה אישית:
<AssignMessage name="copy-ve>rb-<1" Copy source>=&quo<t;re>ques<t&quo>t; < V>erb<true/Verb /Copy AssignTo createNew="true" t>ransport="<http">;< type="re>quest"MyCustomRequest/AssignTo /AssignMessage
אפשר להשתמש ב-<Verb> רק אם מתקיימים הקריטריונים הבאים:
- סוג ההודעה: בקשה
<Version> (ילד של <Copy>)
הפונקציה קובעת אם גרסת ה-HTTP מועתקת מבקשת המקור לבקשת היעד. לרכיב הזה אין השפעה על התשובה.
אם הערך הוא true, המערכת מעתיקה את גרסת ה-HTTP שנמצאת במאפיין source של האלמנט <Copy> לאובייקט שצוין באלמנט <AssignTo>.
| ערך ברירת המחדל | לא נכון |
| חובה? | אופציונלי |
| סוג | בוליאני |
| רכיב אב |
<Copy>
|
| רכיבי צאצא | ללא |
רכיב <Version> משתמש בתחביר הבא:
תחביר
<AssignMessage
continueOnError="[false|true]"
enabled="[true|false]"
> na<me="policy_name"
Co>py so<urce=&q>uot;[request<|respons>e]&<quot;>
< Version[fa>lse|true]/Version
/Copy
/AssignMessageדוגמה 1
בדוגמה הבאה, הערך של <Version> מוגדר כ-true בבקשה, מה שגורם להעתקת הגרסה מאובייקט הבקשה שמוגדר כברירת מחדל לאובייקט בקשה חדש ומותאם אישית:
<AssignMessage name="copy-versi>on-<1" Copy source>=&quo<t;reque>st&q<uot; > Ve<rsion>tru<e/Version /Copy AssignTo createNew="true" t>ransport="<http">;< type="re>quest"MyCustomRequest/AssignTo /AssignMessage
אפשר להשתמש ב-<Version> רק אם מתקיימים הקריטריונים הבאים:
- סוג ההודעה: בקשה
<DisplayName>
אפשר להשתמש במאפיין הזה בנוסף למאפיין name כדי לתת למדיניות שם אחר, שנשמע יותר טבעי, ולתייג אותה בכלי לעריכת ה-proxy בממשק ניהול.
הרכיב <DisplayName> משותף לכל סוגי המדיניות.
| ערך ברירת המחדל | לא רלוונטי |
| חובה? | אופציונלי. אם לא מציינים את <DisplayName>, המערכת משתמשת בערך של מאפיין name של המדיניות |
| סוג | מחרוזת |
| רכיב אב | <PolicyElement> |
| רכיבי צאצא | ללא |
התחביר של רכיב <DisplayName> הוא:
תחביר
<PolicyElement> <DisplayName>policy_display_name</DisplayName> ... </PolicyElement>
דוגמה
<PolicyElement> <DisplayName>My Validation Policy</DisplayName> </PolicyElement>
לרכיב <DisplayName> אין מאפיינים או רכיבי צאצא.
<IgnoreUnresolvedVariables>
קובעת אם העיבוד ייפסק כשנתקלים במשתנה שלא נפתר.
| ערך ברירת המחדל | לא נכון |
| חובה? | אופציונלי |
| סוג | בוליאני |
| רכיב אב |
<AssignMessage>
|
| רכיבי צאצא | ללא |
הערך true גורם להתעלמות ממשתנים שלא נפתרו ולהמשך העיבוד. אחרת
false. ערך ברירת המחדל הוא false.
ההגדרה של <IgnoreUnresolvedVariables> ל-true שונה מההגדרה של continueOnError של <AssignMessage> ל-true, כי היא ספציפית להגדרה ולקבלת ערכים של משתנים. אם מגדירים את continueOnError ל-true, Edge מתעלם מכל השגיאות, ולא רק משגיאות שנתקל בהן כשמשתמשים במשתנים.
רכיב <IgnoreUnresolvedVariables> משתמש בתחביר הבא:
תחביר
<AssignMessage
continueOnError="[false|true]"
enabled="[true|false]"
> na<me="policy_name">;
IgnoreUnre<solvedVariables[true|false>]<
/IgnoreUnre>solvedVariables
/AssignMessageדוגמה 1
בדוגמה הבאה, הערך של <IgnoreUnresolvedVariables> מוגדר ל-true:
<AssignMessage name="AM-Set-Hea>der<s&q>uot; < Set > Head<ers Header name=&#>39;new-header'{possibly<-defin>ed-va<riable}H>ead<er > </Headers /Set IgnoreU>nresolv<edVariablestrue /IgnoreU>n<resolvedVariab>les /AssignMessage
מכיוון שהמדיניות <IgnoreUnresolvedVariables> מוגדרת לערך true, אם המשתנה possibly-defined-variable לא מוגדר, המדיניות הזו לא תגרום לשגיאה.
<Remove>
הסרת כותרות, פרמטרים של שאילתות, פרמטרים של טפסים ו/או מטען הייעודי של ההודעה מהודעה. ההודעה יכולה להיות בקשה או תגובה. כדי לציין על איזו הודעה <Remove>
פועל הרכיב, משתמשים ברכיב <AssignTo>.
| ערך ברירת המחדל | לא רלוונטי |
| חובה? | אופציונלי |
| סוג | סוג מורכב |
| רכיב אב |
<AssignMessage>
|
| רכיבי צאצא |
<FormParams><Headers><Payload><QueryParams> |
מקרה שימוש נפוץ ב-<Remove> הוא מחיקה של פרמטר שאילתה או כותרת שמכילים מידע רגיש מאובייקט הבקשה הנכנסת, כדי להימנע מהעברה שלו לשרת העורפי.
רכיב <Remove> משתמש בתחביר הבא:
תחביר
<AssignMessage continueOnError="[false|true]" enabled="[true|false]" > na<me=&qu>ot;po<licy_name" Remove !-<- Can also >be an empt<y array (F>ormPara<ms/) --> FormParams > FormParam nam<e="fo>rmparam_name&qu<ot;formpara>m_val<ue/FormParam ... /Form<Params > !-- Can< also b>e an em<pty array (Headers/) --&g>t; Heade<rs > Header name=&<quot;hea>der_n<ame&quo>t;header_val<ue/Heade>r < ... /Headers Payload[<false|true]/>Payload < !-- Can a>lso be <an empty array (QueryParams/) --&>gt; QueryPar<ams Q>ueryParam name=<"queryp>ara<m_name&>q<uot;queryparam>_value/QueryParam ... /QueryParams /Remove /AssignMessage
דוגמה 1
בדוגמה הבאה, גוף ההודעה מוסר מהתגובה:
<AssignMessage name="AM-remo>ve-<1" D>isplayNa<meremove-1/D>isp<layNam>e R<emove > P<ayloadtr>ue/<Payload> </Remove > Assign<Torespons>e</AssignTo /Ass>ignMessage
בתהליך התגובה, המדיניות הזו מסירה את גוף התגובה ומחזירה רק כותרות HTTP ללקוח.
דוגמה 2
בדוגמה הבאה מוסרים כל הפרמטרים של הטופס ופרמטר של שאילתה מהאובייקט request:
<AssignMessage name="AM-remo>ve-<2">;
R<emove
!<-- Empty (F>ormParams/) removes all form par>amete<rs --
F>ormPa<rams/
Q>ueryPar<ams
QueryParam n>ame=&<quot;qp1&quo>t;/<
/Q>uer<yParams
> /Remo<ve
Assi>g<nTorequest/Ass>ignTo
/AssignMessageדוגמה 3
בדוגמה הבאה מוסר כל התוכן מאובייקט של הודעה:
<AssignMessage name="AM-remo>ve-<3"> <Remove/ > Assig<nToreques>t</AssignTo /Ass>ignMessage
בדרך כלל עושים את זה רק אם מתכוונים להשתמש ברכיב <Set> או ברכיב <Copy> כדי להגדיר ערכי החלפה בהודעה.
<FormParams> (ילד של <Remove>)
הפונקציה מסירה מהבקשה את הפרמטרים שצוינו בטופס. לרכיב הזה אין השפעה על התגובה.
| ערך ברירת המחדל | לא רלוונטי |
| חובה? | אופציונלי |
| סוג | מערך של רכיבי <FormParam> או מערך ריק |
| רכיב אב |
<Remove>
|
| רכיבי צאצא |
<FormParam> |
רכיב <FormParams> משתמש בתחביר הבא:
תחביר
<AssignMessage continueOnError="[false|true]" enabled="[true|false]" > na<me=&qu>ot;po<licy_name" Remove !-<- Can also >be an empt<y array (F>ormPara<ms/) --> FormParams > FormParam nam<e="fo>rmparam_name&qu<ot;formpara>m_v<alue/Fo>r<mParam .>.. /FormParams /Remove /AssignMessage
דוגמה 1
בדוגמה הבאה, שלושה פרמטרים של טופס מוסרים מהבקשה:
<AssignMessage name="AM-remove-formpara>ms-<1">;
R<emove
>FormPar<ams
FormParam name=">;form_p<aram_1"/
FormParam >name=&q<uot;form_param_2"/
>FormP<aram name=&>quo<t;form_>par<am_3&quo>t;/
< /FormPar>a<ms
/Remove
> AssignTorequest/AssignTo
/AssignMessageדוגמה 2
בדוגמה הבאה מוסרים מהבקשה כל הפרמטרים של הטופס:
<AssignMessage name="AM-remove-formpara>ms-<2">;
R<emove
F>orm<Params/>
</Remove
> Assig<nToreques>t</AssignTo
/Ass>ignMessageדוגמה 3
אם יש כמה פרמטרים של טופס עם אותו שם, משתמשים בתחביר הבא:
<AssignMessage name="AM-remove-formpara>ms-<3">;
R<emove
>FormPar<ams
FormParam >name=&q<uot;f1"/
>FormPar<am name="f2">/
< FormPara>m n<ame=&qu>ot;<f3.2&quo>t;/
< /FormPar>a<ms
/Remove
> AssignTorequest/AssignTo
/AssignMessageבדוגמה הזו מוסרים את f1, f2 והערך השני של f3. אם יש רק ערך אחד ב-f3, הוא לא יוסר.
אפשר להשתמש ב-<FormParams> רק אם מתקיימים הקריטריונים הבאים:
- סוג ההודעה: בקשה
Content-Type: "application/x-www-form-urlencoded"
<Headers> (ילד של <Remove>)
הסרה של כותרות HTTP שצוינו מהבקשה או מהתגובה, שצוינו ברכיב <AssignTo>.
| ערך ברירת המחדל | לא רלוונטי |
| חובה? | אופציונלי |
| סוג | מערך של רכיבי <Header> או מערך ריק |
| רכיב אב |
<Remove>
|
| רכיבי צאצא |
<Header> |
רכיב <Headers> משתמש בתחביר הבא:
תחביר
<AssignMessage continueOnError="[false|true]" enabled="[true|false]" > na<me=&qu>ot;po<licy_name" Remove !-<- Can al>so be an e<mpty ar>ray (He<aders/) -->; Header>s Head<er name>="header_n<ame">;he<ader_va>l<ue/Header > ... /Headers /Remove /AssignMessage
דוגמה 1
בדוגמה הבאה, הכותרת user-agent מוסרת מהבקשה:
<AssignMessage name="AM-remove-one-he>ade<r">;
R<emove
> Head<ers
Header name=&qu>ot;us<er-agent>&qu<ot;/
> /<Headers
> /Remo<ve
Assi>g<nTorequest/Ass>ignTo
/AssignMessageדוגמה 2
בדוגמה הבאה, כל הכותרות מוסרות מהבקשה:
<AssignMessage name="AM-remove-all-hea>der<s">; R<emove > H<eaders/> </Remove > Assig<nToreques>t</AssignTo /Ass>ignMessage
דוגמה 3
אם יש כמה כותרות עם אותו שם, צריך להשתמש בתחביר הבא:
<AssignMessage name="AM-remove-heade>rs-<3">;
R<emove
> Head<ers
Header >name=&q<uot;h1"/
> Head<er name="h2&qu>ot;/
< He>ade<r name=>&qu<ot;h3.2&>quot;/
< /Head>e<rs
/Remove
> AssignTorequest/AssignTo
/AssignMessageבדוגמה הזו מוסרים מהבקשה את הערכים h1, h2 והערך השני של h3. אם לרכיב h3 יש רק ערך אחד, הוא לא יוסר.
<Payload> (ילד של <Remove>)
קובע אם <Remove> מוחק את מטען הייעודי (payload) בבקשה או בתגובה, שמוגדר על ידי הרכיב <AssignTo>. הערך true מוחק את מטען הייעודי (payload), אחרת הערך הוא false. ערך ברירת המחדל הוא false.
| ערך ברירת המחדל | לא נכון |
| חובה? | אופציונלי |
| סוג | בוליאני |
| רכיב אב |
<Remove>
|
| רכיבי צאצא | ללא |
רכיב <Payload> משתמש בתחביר הבא:
תחביר
<AssignMessage continueOnError="[false|true]" enabled="[true|false]" > na<me=&qu>ot;po<licy_na>me" <Remove > <Payload>[<false|true]/Pa>yload /Remove /AssignMessage
דוגמה 1
בדוגמה הבאה, הערך של <Payload> מוגדר כ-true, כך שמטען הייעודי (payload) של הבקשה ינוקה:
<AssignMessage name="AM-remove-paylo>ad-<1">; R<emove > P<ayloadtr>ue/<Payload> </Remove > Assig<nToreques>t</AssignTo /Ass>ignMessage
<QueryParams> (ילד של <Remove>)
הפונקציה מסירה מהבקשה את הפרמטרים שצוינו של השאילתה. לרכיב הזה אין השפעה על התגובה.
| ערך ברירת המחדל | לא רלוונטי |
| חובה? | אופציונלי |
| סוג | מערך של רכיבי <QueryParam> או מערך ריק |
| רכיב אב |
<Remove>
|
| רכיבי צאצא |
<QueryParam> |
רכיב <QueryParams> משתמש בתחביר הבא:
תחביר
<AssignMessage continueOnError="[false|true]" enabled="[true|false]" > na<me=&qu>ot;po<licy_name" Remove !-<- Can also b>e an empty< array (Que>ryParam<s/) --> QueryParams >QueryParam name=<"query>param_name"<;queryparam_>val<ue/Quer>y<Param ..>. /QueryParams /Remove /AssignMessage
דוגמה 1
בדוגמה הבאה מוסר פרמטר שאילתה יחיד מהבקשה:
<AssignMessage name="AM-remove-querypara>ms-<1">;
Rem<ove
Q>ueryParam<s
QueryParam n>ame=&qu<ot;qp1">/
< /Q>uer<yParams
> /Remo<ve
Assi>g<nTorequest/Ass>ignTo
/AssignMessageדוגמה 2
בדוגמה הבאה מוסרים כל פרמטרי השאילתה מהבקשה:
<AssignMessage name="AM-remove-querypara>ms-<2">;
Rem<ove
Qu>ery<Params/>
</Remove
> Assig<nToreques>t</AssignTo
/Ass>ignMessageדוגמה 3
אם יש כמה פרמטרים של שאילתה עם אותו שם, צריך להשתמש בתחביר הבא:
<AssignMessage name="AM-remove-querypara>ms-<3">;
Rem<ove
Q>ueryParam<s
QueryParam n>ame="<;qp1"/
Qu>eryParam <name="qp2"/
> Q<ueryParam na>me=<"q>p3.<2"/>
</QueryPar>a<ms
/Remove
> AssignTorequest/AssignTo
/AssignMessageבדוגמה הזו, הערכים qp1, qp2 והערך השני של qp3 מוסרים מהבקשה. אם ל-qp3 יש רק ערך אחד, הוא לא יוסר.
דוגמה 4
בדוגמה הבאה מוסר פרמטר השאילתה apikey מהבקשה:
<AssignMessage name="AM-remove-query-p>ara<m">;
R<emove
Q>ueryPar<ams
QueryParam name>=&quo<t;apikey&quo>t;/<
/Q>uer<yParams
> /Remo<ve
Assi>g<nTorequest/Ass>ignTo
/AssignMessageאפשר להשתמש ב-<QueryParams> רק אם מתקיימים הקריטריונים הבאים:
- פועל HTTP: GET
- סוג ההודעה: בקשה
<Set>
הגדרת מידע בהודעת הבקשה או התגובה, שצוין על ידי הרכיב <AssignTo>. <Set> מחליף כותרות או פרמטרים של שאילתות או טפסים שכבר קיימים בהודעה המקורית. כותרות ופרמטרים של שאילתות וטפסים בהודעת HTTP יכולים להכיל כמה ערכים. כדי להוסיף ערכים נוספים לכותרת או לפרמטר, צריך להשתמש ברכיב <Add>.
| ערך ברירת המחדל | לא רלוונטי |
| חובה? | אופציונלי |
| סוג | סוג מורכב |
| רכיב אב |
<AssignMessage>
|
| רכיבי צאצא |
<FormParams><Headers><Payload><Path><QueryParams><ReasonPhrase><StatusCode><Verb><Version> |
רכיב <Set> משתמש בתחביר הבא:
תחביר
<AssignMessage continueOnError="[false|true]" enabled="[true|false]" > na<me=>"<;policy_na>me"<; Set FormParams F>ormParam name=&<quot;formp>aram_name"<formparam_v>alue/<FormPar>am < ... /FormParams > Headers < Head>er name="h<eader_na>me&qu<ot;h>eade<r_val>ue/He<ader ... /Headers Pathpath/Path Payload contentType="content_type&q>uot; variab<lePrefix>=&quo<t;prefix&qu>ot; < variableSuffix="suffix&>quot;new_payload</Payload > QueryParams < QueryPa>ram n<ame="qu>eryparam_name"queryparam_<value/QueryPa>ram < ... > /QueryParams ReasonPhra<sereason_fo>r_err<or o>r {variable}/ReasonPhrase StatusCo<deHTT>P_sta<tus_cod>e or {variable}/Stat<usCod>e < V>e<rb[GET|POST|PU>T|PATCH|DELETE|{variable}]/Verb Version[1.0|1.1|{variable}]/Verb /Set /AssignMessage
דוגמה 1
בדוגמה הבאה מוגדרת כותרת ספציפית. כשהמדיניות הזו מצורפת לזרימת הבקשה, היא מאפשרת למערכת במעלה הזרם לקבל כותרת נוספת שלא נכללה בבקשה המקורית הנכנסת.
<AssignMessage name="AM-Set-He>ade<r&q>uot;
< Set
> Header<s
Header name="authentic>ated-developer"{verifyapikey<.VAK-1.>devel<oper.id}>/He<ader>
< /Heade>rs
/S<et
Assi>g<nTorequest/Ass>ignTo
/AssignMessageדוגמה 2
בדוגמה הבאה מתבצעת החלפה של המטען הייעודי (payload) של התגובה וגם של הכותרת Content-Type.
<AssignMessage name="AM-Overwrite-Pay>loa<d&q>uot; < Set Payload contentType="ap>plication/json&qu<ot;{ &qu>ot;<stat>us&<quot; : >42 }/Pay<load /S>e<t AssignTore>sponse/AssignTo /AssignMessage
<FormParams> (ילד של <Set>)
הפעולה הזו מחליפה פרמטרים קיימים בטופס בבקשה ומחליפה אותם בערכים החדשים שאתם מציינים באמצעות הרכיב הזה. לרכיב הזה אין השפעה על התשובה.
| ערך ברירת המחדל | לא רלוונטי |
| חובה? | אופציונלי |
| סוג | מערך של <FormParam> רכיבים |
| רכיב אב |
<Set>
|
| רכיבי צאצא |
<FormParam> |
רכיב <FormParams> משתמש בתחביר הבא:
תחביר
<AssignMessage
continueOnError="[false|true]"
enabled="[true|false]"
> na<me=>"<;policy_na>me"<;
Set
FormParams
F>ormParam name=&<quot;formp>aram_name"<formparam_v>alu<e/Fo>r<mParam
.>..
/FormParams
/Set
/AssignMessageדוגמה 1
בדוגמה הבאה מוגדר פרמטר של טופס בשם myparam לערך של המשתנה request.header.myparam בבקשה חדשה ומותאמת אישית:
<AssignMessage name="AM-set-formpara>ms-<1&q>uot; < Set >FormPar<ams FormParam name>="myparam"{req<uest.heade>r.myp<aram}/FormP>ara<m > /<FormParams /Set AssignTo createNew="true" t>ransport="<http">;< type="re>quest"MyCustomRequest/AssignTo /AssignMessage
אפשר להשתמש ב-<FormParams> רק אם מתקיימים הקריטריונים הבאים:
- פועל HTTP: POST
- סוג ההודעה: בקשה
אם מגדירים פרמטרים ריקים של טופס במדיניות (<Add><FormParams/></Add>), המדיניות לא מוסיפה פרמטרים של טופס. זה כמו להשמיט את <FormParams>.
<Set> משנה את Content-Type של ההודעה ל-application/x-www-form-urlencoded לפני השליחה לנקודת הקצה של היעד.
<Headers> (ילד של <Set>)
הפעולה מחליפה כותרות HTTP קיימות בבקשה או בתגובה, שמוגדרות על ידי הרכיב <AssignTo>.
| ערך ברירת המחדל | לא רלוונטי |
| חובה? | אופציונלי |
| סוג | מערך של <Header> רכיבים |
| רכיב אב |
<Set>
|
| רכיבי צאצא |
<Header> |
רכיב <Headers> משתמש בתחביר הבא:
תחביר
<AssignMessage
continueOnError="[false|true]"
enabled="[true|false]"
> na<me=>"<;policy>_name&q<uot;
Set
Headers
> Header <name=&q>uot;header_name<"he>ade<r_va>l<ue/Header
> ...
/Headers
/Set
/AssignMessageדוגמה 1
בדוגמה הבאה, הכותרת x-ratelimit-remaining מוגדרת לערך של המשתנה ratelimit.Quota-1.available.count:
<AssignMessage name="AM-Set-RateLimit-He>ade<r&q>uot;
< Set
> Head<ers
Header name="X-RateL>imit-Remaining"{ratelimit.Quot<a-1.ava>ilabl<e.count}>/He<ader>
< /Heade>rs
/Se<t
Assig>n<Toresponse/Ass>ignTo
/AssignMessageאם מגדירים כותרות ריקות במדיניות
(<Set><Headers/></Set>), המדיניות לא מגדירה כותרות. הפעולה הזו תהיה זהה להשמטת <Headers>.
<Path> (ילד של <Set>)
<Payload> (ילד של <Set>)
הגדרת גוף ההודעה לבקשה או לתגובה, שמוגדר על ידי הרכיב <AssignTo>. המטען הייעודי יכול להיות כל סוג תוכן תקין, כמו טקסט פשוט, JSON או XML.
| ערך ברירת המחדל | מחרוזת ריקה |
| חובה? | אופציונלי |
| סוג | מחרוזת |
| רכיב אב |
<Set>
|
| רכיבי צאצא | ללא |
רכיב <Payload> משתמש בתחביר הבא:
תחביר
<AssignMessage continueOnError="[false|true]" enabled="[true|false]" > na<me=>"<;policy_name" Set Payload contentType="content_type" variablePrefix=>"prefi<x"<>/span> < > <variableSuffix>="suffix"new_payload/Payload /Set /AssignMessage
דוגמה 1
בדוגמה הבאה מוגדר מטען ייעודי (payload) של טקסט פשוט:
<AssignMessage name="set-paylo>ad-<1&q>uot; < Set Payload contentType=&q>uo<t;text/p>lai<n&qu>o<t;42/Payload > /Set /AssignMessage
דוגמה 2
בדוגמה הבאה מוגדר מטען ייעודי (payload) של JSON:
<AssignMessage name="set-paylo>ad-<2&q>uot; < Set Payload contentType="ap>plication/json" {"name&q<uot;:&qu>ot;<foo&>q<uot;, "ty>pe":"bar"} /Payload /Set /AssignMessage
דוגמה 3
בדוגמה הבאה, ערכי משתנים מוכנסים למטען הייעודי (payload) על ידי הוספת סוגריים מסולסלים לשמות המשתנים:
<AssignMessage name="set-paylo>ad-<3&q>uot; < Set Payload contentType="ap>plication/json" {"name":"f<oo">, &<quot>;<type":&qu>ot;{variable_name}"} /Payload /Set /AssignMessage
בגרסאות קודמות של Apigee, לא הייתה אפשרות להשתמש בסוגריים מסולסלים כדי לציין הפניות למשתנים במטענים ייעודיים (payloads) של JSON. בגרסאות האלה, היה צריך להשתמש במאפיינים variablePrefix ו-variableSuffix כדי לציין תווים של תווי הפרדה, ולהשתמש בהם כדי לתחום שמות של משתנים, כמו בדוגמה הבאה:
<AssignMessage name="set-payloa>d-3<b&q>uot; < Set Payload contentType="application/json" variablePrefix=&q>uot;@" variableSuffix="#" {&quo<t;name&q>uot<;:&q>u<ot;foo", >"type":"@variable_name#"} /Payload /Set /AssignMessage
התחביר הישן הזה עדיין עובד.
דוגמה 4
התוכן של <Payload> מטופל כתבנית של הודעה. המשמעות היא שמדיניות AssignMessage מחליפה משתנים שמוקפים בסוגריים מסולסלים בערך של המשתנים שאליהם מתבצעת ההפניה בזמן הריצה.
בדוגמה הבאה נעשה שימוש בתחביר של סוגריים מסולסלים כדי להגדיר חלק מהמטען הייעודי (payload) כערך משתנה:
<AssignMessage name="set-paylo>ad-<4&q>uot; < Set Payload contentType=>"t<ext/>xml"< > r<oot> <e1>sunday</e1> <e2>funday</e2> < e3{>var1}</e3 > /<root> < /Payload > /Set /AssignMessage
בטבלה הבאה מתוארים המאפיינים של <Payload>:
| מאפיין | תיאור | נוכחות | סוג |
|---|---|---|---|
contentType |
אם מציינים ערך, הערך של |
אופציונלי | מחרוזת |
variablePrefix |
מציין באופן אופציונלי את התו המפריד המוביל במשתנה של זרימת נתונים. ברירת המחדל היא '{'. מידע נוסף זמין במאמר חומר עזר בנושא משתני זרימה. | אופציונלי | Char |
variableSuffix |
אפשר לציין תו מפריד בסוף משתנה של זרימת נתונים. ברירת המחדל היא "}". מידע נוסף זמין במאמר חומר עזר בנושא משתני זרימה. | אופציונלי | Char |
<QueryParams> (ילד של <Set>)
הפרמטר מחליף ערכים קיימים של פרמטרים של שאילתות בבקשה בערכים חדשים. לרכיב הזה אין השפעה על התשובה.
| ערך ברירת המחדל | לא רלוונטי |
| חובה? | אופציונלי |
| סוג | מערך של <QueryParam> רכיבים |
| רכיב אב |
<Set>
|
| רכיבי צאצא |
<QueryParam> |
רכיב <QueryParams> משתמש בתחביר הבא:
תחביר
<AssignMessage
continueOnError="[false|true]"
enabled="[true|false]"
> na<me=>"<;policy_nam>e"<
Set
QueryParams
Que>ryParam name=&qu<ot;querypar>am_name"qu<eryparam_val>ue/<Quer>y<Param
..>.
/QueryParams
/Set
/AssignMessageדוגמה 1
בדוגמה הבאה מוגדר פרמטר השאילתה address עם הערך של המשתנה request.header.address:
<AssignMessage name="AM-set-querypara>ms<-1&>quot;< Set Q>ueryPar<ams QueryParam name>="address"{req<uest.header>.addr<ess}/QueryPa>ram< > </QueryParams > /Set /AssignMessage
אפשר להשתמש ב-<QueryParams> רק אם מתקיימים הקריטריונים הבאים:
- פועל HTTP: GET
- סוג ההודעה: בקשה
אם מגדירים פרמטרים ריקים של שאילתה במדיניות (<Set><QueryParams/></Set>), המדיניות לא מגדירה פרמטרים של שאילתה. זה כמו להשמיט את <QueryParams>.
<ReasonPhrase> (ילד של <Set>)
מגדיר את משפט הסיבה בתגובה. הפעולה הזו מתבצעת בדרך כלל לצורך ניפוי באגים בשילוב עם <StatusCode>. לרכיב הזה אין השפעה על בקשה.
| ערך ברירת המחדל | לא רלוונטי |
| חובה? | אופציונלי |
| סוג | מחרוזת |
| רכיב אב |
<Set>
|
| רכיבי צאצא | ללא |
רכיב <ReasonPhrase> משתמש בתחביר הבא:
תחביר
<AssignMessage continueOnError="[false|true]" enabled="[true|false]" > na<me=>"<;policy_name>" Set ReasonPhrase<reason_for_er>ror< or >{<variable}/Reas>onPhrase /Set /AssignMessage
דוגמה 1
בדוגמה הבאה מוגדרת סיבת סטטוס פשוטה:
<AssignMessage name="set-reasonphra>se-<1&q>uot; < Set Re>asonPhraseBa<d medicine/Re>aso<nPhr>ase< /Set AssignTo createNew="true" transport=&qu>o<t;http" t>ype="response"/ /AssignMessage
דוגמה 2
התוכן של <ReasonPhrase> מטופל כתבנית של הודעה. המשמעות היא ששם של משתנה שמוקף בסוגריים מסולסלים יוחלף בזמן הריצה בערך של המשתנה שאליו מתבצעת ההפניה, כמו בדוגמה הבאה:
<AssignMessage name="AM-set-reasonphra>se-<2&q>uot;
< Set
Re>asonPhrase{calloutresponse.reas<on.phrase}/Re>aso<nPhr>ase<
/Set
> Assign<Torespons>e</AssignTo
/Ass>ignMessageאפשר להשתמש ב-<ReasonPhrase> רק אם מתקיימים הקריטריונים הבאים:
- סוג ההודעה: תגובה
<StatusCode> (ילד של <Set>)
הפונקציה מגדירה את קוד הסטטוס בתשובה. לרכיב הזה אין השפעה על בקשה.
| ערך ברירת המחדל | '200' (כשהמאפיין createNew של <AssignTo> מוגדר כ-'true') |
| חובה? | אופציונלי |
| סוג | מחרוזת או variable |
| רכיב אב |
<Set>
|
| רכיבי צאצא | ללא |
רכיב <StatusCode> משתמש בתחביר הבא:
תחביר
<AssignMessage continueOnError="[false|true]" enabled="[true|false]" > na<me=>"<;policy_na>me" Set StatusCode<HTTP_status>_co<de o>r< {variable}/St>atusCode /Set /AssignMessage
דוגמה 1
בדוגמה הבאה מוגדר קוד סטטוס פשוט:
<AssignMessage name="AM-set-statuscode>-40<4&q>uot;
< Set
>Sta<tusCode404/>Sta<tusC>ode<
/Set
> Assign<Torespons>e</AssignTo
/Ass>ignMessageדוגמה 2
התוכן של <StatusCode> מטופל כתבנית של הודעה. המשמעות היא ששם משתנה שמוקף בסוגריים מסולסלים יוחלף בזמן הריצה בערך של המשתנה שאליו מתבצעת ההפניה, כמו בדוגמה הבאה:
<AssignMessage name="set-statusco>de-<2&q>uot;
< Set
>StatusCode{calloutresponse.st<atus.code}/>Sta<tusC>ode<
/Set
> Assign<Torespons>e</AssignTo
/Ass>ignMessageאפשר להשתמש ב-<StatusCode> רק אם מתקיימים הקריטריונים הבאים:
- סוג ההודעה: תגובה
<Verb> (ילד של <Set>)
מגדיר את פועל ה-HTTP בבקשה. לרכיב הזה אין השפעה על התשובה.
| ערך ברירת המחדל | לא רלוונטי |
| חובה? | אופציונלי |
| סוג | מחרוזת או variable |
| רכיב אב |
<Set>
|
| רכיבי צאצא | ללא |
רכיב <Verb> משתמש בתחביר הבא:
תחביר
<AssignMessage continueOnError="[false|true]" enabled="[true|false]" > na<me=>"<;pol>icy_name" Set Verb[GET|POS<T|PUT>|PA<TCH|>D<ELETE|{variabl>e}]/Verb /Set /AssignMessage
דוגמה 1
בדוגמה הבאה מוגדר פועל פשוט בבקשה:
<AssignMessage name="AM-set-ve>rb-<1&q>uot; < Se>t < Ver>bPO<ST/V>erb< /Set > Assig<nToreques>t</AssignTo /Ass>ignMessage
דוגמה 2
התוכן של <Verb> מטופל כתבנית של הודעה. המשמעות היא ששם של משתנה
שמוקף בסוגריים מסולסלים יוחלף בזמן הריצה בערך של המשתנה שאליו מתבצעת ההפניה.
בדוגמה הבאה משתמשים במשתנה כדי לאכלס פועל:
<AssignMessage name="AM-set-verb-to-dynamic-v>alu<e&q>uot; < Se>t Verb{my<_vari>abl<e}/V>erb< /Set > Assig<nToreques>t</AssignTo /Ass>ignMessage
אפשר להשתמש ב-<Verb> רק אם מתקיימים הקריטריונים הבאים:
- סוג ההודעה: בקשה
<Version> (ילד של <Set>)
הגדרת גרסת ה-HTTP בבקשה. לרכיב הזה אין השפעה על התשובה.
| ערך ברירת המחדל | לא רלוונטי |
| חובה? | אופציונלי |
| סוג | מחרוזת או variable |
| רכיב אב |
<Set>
|
| רכיבי צאצא | ללא |
רכיב <Version> משתמש בתחביר הבא:
תחביר
<AssignMessage continueOnError="[false|true]" enabled="[true|false]" > na<me=>"<;policy>_name" Set < Ve>rsi<on[1>.<0|1.1|{variabl>e}]/Verb /Set /AssignMessage
דוגמה 1
בדוגמה הבאה, מספר הגרסה מוגדר כ-1.1:
<AssignMessage name="AM-set-versi>on-<1&q>uot; < Set > <Version1>.1/<Vers>io<n /Set /Ass>ignMessage
דוגמה 2
בדוגמה הבאה נעשה שימוש במשתנה בסוגריים מסולסלים כדי להגדיר את מספר הגרסה:
<AssignMessage name="AM-set-versi>on-<2&q>uot;
< Set
> Version{m<y_versio>n}/<Vers>ion<
/Set
> Assig<nToreques>t</AssignTo
/Ass>ignMessageהתוכן של <Version> מטופל כתבנית של הודעה. המשמעות היא ששם של משתנה שמוקף בסוגריים מסולסלים יוחלף בזמן הריצה בערך של המשתנה שאליו מתבצעת ההפניה.
אפשר להשתמש ב-<Version> רק אם מתקיימים הקריטריונים הבאים:
- סוג ההודעה: בקשה
יצירת הודעות בקשה בהתאמה אישית
אפשר להשתמש במדיניות AssignMessage כדי ליצור הודעת בקשה בהתאמה אישית. אחרי שיוצרים בקשה בהתאמה אישית, אפשר להשתמש בה בדרכים הבאות:
- גישה למשתנים שלה במדיניות אחרת
- העברה לשירות חיצוני
כדי ליצור הודעת בקשה בהתאמה אישית, משתמשים ברכיב <AssignTo> במדיניות AssignMessage. מגדירים את createNew לערך true ומציינים את השם של ההודעה החדשה בגוף של הרכיב, כמו בדוגמה הבאה:
<AssignMessage name="AM-assign>to-2<" AssignTo createNew="true" transport=&>quot;http" <type=&quo>t;<request"N>ameOfNewMessage/AssignTo /AssignMessage
כברירת מחדל, Edge לא עושה כלום עם הודעת הבקשה המותאמת אישית. אחרי שיוצרים את הבקשה, Edge ממשיך בתהליך עם הבקשה המקורית. כדי להשתמש בבקשה מותאמת אישית, מוסיפים לממשק ה-proxy מדיניות כמו מדיניות ServiceCallout, שיכולה להעביר את הבקשה המותאמת אישית לשירות חיצוני.
בדוגמאות הבאות מוצגות הודעות בקשה מותאמות אישית:
דוגמה 1
בדוגמה הבאה נוצר אובייקט בקשה בהתאמה אישית עם Assign Message:
<AssignMessage name="AssignMessa>ge-<3" AssignTo createNew="true&>quot; type=&quo<t;request>&qu<ot;M>yCust<omReque>st/Ass<ignTo Copy Headers > <Header n>ame<=&quo>t;u<ser>-agen<t"/ > /Head<ers /Copy Set Que>ryParams QueryParam< name=">;addr<ess"{re>quest<.que>ryp<aram.>add<y}/Q>uer<yParam /QueryParams > VerbG<ET/Verb /Set IgnoreUnr>e<solvedVariable>sfalse /IgnoreUnresolvedVariables /AssignMessage
בדוגמה הזו:
- יוצר אובייקט חדש של הודעת בקשה בשם MyCustomRequest.
- ב-MyCustomRequest, המדיניות הזו:
- מעתיק את הערך של כותרת ה-HTTP
user-agentמהבקשה הנכנסת להודעה החדשה. מכיוון שהפונקציה<Copy>משתמשת בהפניה מוחלטת למשתנה של זרימת הנתוניםuser-agent, אין צורך לציין את המאפייןsourceלפונקציה<Copy>. - מגדיר את פרמטר השאילתה
addressבהודעה המותאמת אישית לערך של פרמטר השאילתהaddyשל הבקשה הנכנסת. - מגדיר את פועל ה-HTTP לערך
GET.
- מעתיק את הערך של כותרת ה-HTTP
- הערך של
<IgnoreUnresolvedVariables>מוגדר כ-false. אם הערך של<IgnoreUnresolvedVariables>הוא false, ואחד מהמשתנים שהמדיניות מנסה להוסיף לא קיים, Edge יפסיק את העיבוד בזרימת ה-API.
דוגמה 2
דוגמה נוספת שמראה איך ליצור אובייקט בקשה בהתאמה אישית באמצעות AssignMessage:
<AssignMessage name="AssignMessa>ge-<2" AssignTo createNew="true&>quot; type=&quo<t;request>&qu<ot;>partn<er.r>eque<st/As>signT<o Set VerbPOST/Verb >Payload< conten><tType=&qu>ot;<text/xml&q><uot; > re<questope>rat<ion1>0<5/operation/re>quest /Payload /Set /AssignMessage
בדוגמה הזו נוצרת בקשה חדשה בהתאמה אישית בשם partner.request. לאחר מכן, המערכת מגדירה את הערכים <Verb> ו-<Payload> בבקשה החדשה.
אפשר לגשת להודעת בקשה בהתאמה אישית במדיניות אחרת של AssignMessage שמופיעה בהמשך התהליך. בדוגמה הבאה מקבלים את הערך של הכותרת user-agent של הודעת הבקשה המותאמת אישית:
<AssignMessage name="custom-request-1-ac>ces<s"
D>isplayNamecustom-reques<t-1-access/D>isp<layName
> AssignTopartn<er.reques>t/A<ssi>gnTo
< Set
> Head<ers
Header name="user-agentCop>yCustomRequest"{MyCustomReques<t.heade>r.use<r-agent}>/He<ader>
< /Headers
> /Set
/AssignMessageסרטונים
כדאי לצפות בסרטונים הבאים כדי לקבל מידע נוסף על המדיניות בנושא AssignMessage.
| וידאו | תיאור |
|---|---|
| למה כדאי להקצות מדיניות הודעות? | כאן אפשר לקרוא על היתרונות של שימוש במדיניות AssignMessage כדי לשנות את הבקשה או התגובה של ה-API בלי לשנות את קוד ה-Backend. |
| העתקת רכיבי API באמצעות מדיניות AssignMessage | העתקת רכיבים מבקשה או מתשובה של API ויצירת אובייקט בקשה או תשובה חדש באמצעות מדיניות AssignMessage. |
| הסרת רכיבי API באמצעות מדיניות AssignMessage | מסירים רכיבי API ומשנים את ה-API לפני שהוא מגיע לשרת העורפי של היעד באמצעות המדיניות AssignMessage. |
| הוספה והגדרה של רכיבי API באמצעות מדיניות AssignMessage | שינוי בקשת API או תגובה על ידי הוספה של פרמטרים של שאילתות, כותרות, פרמטרים של טפסים או מטענים ייעודיים (payloads) באמצעות מדיניות AssignMessage. |
| יצירת משתנים מותאמים אישית באמצעות מדיניות AssignMessage | הגדרת משתני תהליך עבודה מותאמים אישית באמצעות מדיניות AssignMessage ושימוש במשתנים במדיניות אחרת ב-API proxy. |
| יצירת אובייקטים חדשים של בקשות או תגובות באמצעות מדיניות AssignMessage | יוצרים אובייקטים חדשים של בקשות או תגובות ל-API באמצעות מדיניות AssignMessage בזמן הריצה של ה-API. |
| יצירת API מדומה באמצעות מדיניות AssignMessage | כדי ליצור API פשוט ל-REST לצורך הדמיה, מוסיפים את מדיניות AssignMessage בתהליך התגובה. |
| הגדרה או שינוי של מטען ייעודי (payload) באמצעות מדיניות AssignMessage | ממירים בקשת REST לבקשת SOAP על ידי הגדרת SOAP Payload באמצעות מדיניות AssignMessage בזמן הריצה של ה-API. |
קודי שגיאה
בקטע הזה מתוארים קודי השגיאה והודעות השגיאה שהוחזרו, ומשתני התקלה שמוגדרים על ידי Edge כשהמדיניות הזו גורמת לשגיאה. חשוב לדעת את המידע הזה אם אתם מפתחים כללי כשל כדי לטפל בתקלות. מידע נוסף זמין במאמר מה צריך לדעת? מידע על שגיאות שקשורות למדיניות וטיפול פגמים.
שגיאות זמן ריצה
השגיאות האלה עשויות להתרחש כשהמדיניות מופעלת.
| קוד תקלה | סטטוס HTTP | סיבה | תיקון |
|---|---|---|---|
steps.assignmessage.SetVariableFailed |
500 | המדיניות לא הצליחה להגדיר משתנה. לראות את מחרוזת השגיאה של שם ה- משתנה שלא נפתר. | |
steps.assignmessage.VariableOfNonMsgType |
500 |
השגיאה הזו מתקבלת אם המאפיין משתנים של סוגי הודעות מייצגים את כל הבקשות והתשובות של HTTP. אפליקציית Edge המובנית
משתני הזרימה |
build |
steps.assignmessage.UnresolvedVariable |
500 |
השגיאה הזו מתקבלת אם המשתנה שצוין במדיניות 'הקצאת הודעה' הוא:
|
build |
שגיאות פריסה
השגיאות האלה עשויות להתרחש כאשר פורסים שרת proxy שמכיל את המדיניות הזו.
| שם השגיאה | סיבה | תיקון |
|---|---|---|
InvalidIndex |
אם האינדקס שצוין ברכיבים <Copy> ו/או <Remove> של הקצאת ההודעה
היא 0 או מספר שלילי, אז הפריסה של שרת ה-proxy ל-API נכשלת.
|
build |
InvalidVariableName |
אם רכיב הצאצא <Name> ריק או לא צוין ברכיב <AssignVariable>,
הפריסה של שרת ה-proxy ל-API נכשלת כי אין שם משתנה חוקי
שצריך להקצות לו ערך. צריך להזין שם משתנה חוקי.
|
build |
InvalidPayload |
מטען ייעודי (payload) שצוין במדיניות אינו חוקי. |
משתני כשל
המשתנים האלה מוגדרים כשהמדיניות הזו גורמת לשגיאה בזמן הריצה. לקבלת מידע נוסף, ראה מה לדעת על שגיאות שקשורות למדיניות.
| משתנים | איפה | דוגמה |
|---|---|---|
fault.name="fault_name" |
fault_name הוא שם השגיאה, כפי שמצוין בטבלה שגיאות זמן ריצה שלמעלה. שם השגיאה הוא החלק האחרון בקוד השגיאה. | fault.name Matches "UnresolvedVariable" |
assignmessage.policy_name.failed |
policy_name הוא השם שצוין על ידי המשתמש של המדיניות שגרמה לבעיה. | assignmessage.AM-SetResponse.failed = true |
דוגמה לתגובת שגיאה
{ "fault":{ "detail":{ "errorcode":"steps.assignmessage.VariableOfNonMsgType" }, "faultstring":"AssignMessage[AM-SetResponse]: value of variable is not of type Message" } }
דוגמה לכלל שגוי
<FaultRule name="Assign Message Faults"> <Step> <Name>AM-CustomNonMessageTypeErrorResponse</Name> <Condition>(fault.name Matches "VariableOfNonMsgType") </Condition> </Step> <Step> <Name>AM-CustomSetVariableErrorResponse</Name> <Condition>(fault.name = "SetVariableFailed")</Condition> </Step> <Condition>(assignmessage.failed = true) </Condition> </FaultRule>
סכימות
כל סוג מדיניות מוגדר על ידי סכימת XML (.xsd). סכימות מדיניות זמינות ב-GitHub.
נושאים קשורים
דוגמאות עבודה של מדיניות AssignMessage זמינות בדוגמאות של API Platform.
דוגמה מתקדמת יותר להחלפת הערך target.url מ-ProxyEndpoint מופיעה במאמר הזה בקהילת Apigee.
כדי לראות איך פועלת מדיניות ServiceCallout עם הגדרת נתיב, אפשר לעיין בדוגמה הזו לתרגול מעשי בדוגמאות של Apigee ב-GitHub. פשוט משכפלים את המאגר ופועלים לפי ההוראות בנושא הזה. בדוגמה נעשה שימוש במדיניות AssignMessage כדי להגדיר נתיב בקשה, ואז נעשה שימוש במדיניות Service Callout כדי לשלוח את הבקשה לשירות חיצוני.