המדיניות PromptTokenLimit

מדיניות ניתנת להרחבה

הדף הזה מתייחס ל-Apigee, אבל לא ל-Apigee Hybrid.

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

סקירה כללית

המדיניות PromptTokenLimit מגנה על קצה העורף של מודלים גדולים של שפה (LLM) מפני עליות פתאומיות בתנועת הנתונים, על ידי הגבלת מספר הטוקנים בהנחיות למשתמשים.

המדיניות PromptTokenLimit דומה למדיניות SpikeArrest, אבל מדיניות SpikeArrest מגבילה את מספר הבקשות, ומדיניות PromptTokenLimit מגבילה את מספר הטוקנים בבקשות האלה. המדיניות הזו מותאמת במיוחד לאפליקציות של מודלים גדולים של שפה (LLM), שבהן העלות והביצועים קשורים ישירות למספר הטוקנים שעוברים עיבוד.

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

ההבדל בין PromptTokenLimit לבין LLMTokenQuota

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

רכיב PromptTokenLimit

הגדרת המדיניות PromptTokenLimit.

ערך ברירת המחדל	מידע נוסף מופיע בכרטיסייה מדיניות ברירת המחדל שבהמשך
חובה?	אופציונלי
סוג	אובייקט מורכב
רכיב אב	לא רלוונטי
רכיבי צאצא	<Identifier> <Rate> (חובה) <UseEffectiveCount> <UserPromptSource> <IgnoreUnresolvedVariables>

תחביר

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

<PromptTokenLimit continueOnError="false" enabled="true" name="POLICY_NAME">
  <DisplayName></DisplayName>
  <Properties/>
  <UserPromptSource>{jsonPath('$.contents[-1].parts[-1].text',request.content,true)}</UserPromptSource>
  <Identifier ref=""/>
  <Rate ref="">[pm|ps]</Rate>
  <UseEffectiveCount>[false|true]</UseEffectiveCount>
  <IgnoreUnresolvedVariables>[false|true]</IgnoreUnresolvedVariables>
</PromptTokenLimit>
      

מדיניות ברירת המחדל

בדוגמה הבאה מוצגות הגדרות ברירת המחדל כשמוסיפים מדיניות PromptTokenLimit לזרימה בממשק המשתמש:

<PromptTokenLimit continueOnError="false" enabled="true" name="PTL-limitTokens-1">
  <DisplayName></DisplayName>
  <Properties/>
  <UserPromptSource>{jsonPath('$.contents[-1].parts[-1].text',request.content,true)}</UserPromptSource>
  <Identifier ref=""/>
  <Rate ref="">[pm|ps]</Rate>
  <UseEffectiveCount>[false|true]</UseEffectiveCount>
  <IgnoreUnresolvedVariables>[false|true]</IgnoreUnresolvedVariables>
</PromptTokenLimit>
      

לרכיב הזה יש את המאפיינים הבאים שמשותפים לכל המדיניות:

מאפיין	ברירת מחדל	חובה?	תיאור
name	לא רלוונטי	חובה	השם הפנימי של המדיניות. הערך של מאפיין name יכול להכיל אותיות, מספרים, רווחים, מקפים, קווים תחתונים ונקודות. הערך הזה לא יכול להיות ארוך מ-255 תווים. אפשר להשתמש ברכיב <DisplayName> כדי לתת למדיניות תווית בשם אחר בשפה טבעית בכלי לעריכת פרוקסי בממשק המשתמש לניהול.
continueOnError	FALSE	אופציונלי	מגדירים את הערך false כדי להחזיר שגיאה אם המדיניות נכשלת. זו התנהגות צפויה ברוב המקרים. הגדרה ל-true מאפשרת להמשיך את הביצוע של התהליך גם אחרי שמדיניות נכשלת. מאמרים קשורים: הפעלת כללי תקלות מתבצעת רק במצב שגיאה (מידע על continueOnError) טיפול בתקלות בתהליך הנוכחי
enabled	TRUE	אופציונלי	מגדירים את הערך true כדי לאכוף את המדיניות, או את הערך false כדי להשבית את המדיניות. המדיניות לא נאכפת גם אם היא עדיין משויכת לזרימה.
async	FALSE	הוצא משימוש	המאפיין הזה הוצא משימוש.

דוגמאות

בדוגמאות הבאות אפשר לראות כמה מהדרכים שבהן אפשר להשתמש במדיניות PromptTokenLimit:

דוגמה 1

הגבלת טוקנים של הנחיות בתוך רפליקה אחת.

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

<PromptTokenLimit continueOnError="false" enabled="true" name="PTL-limitTokens-1">
  <DisplayName></DisplayName>
  <Properties/>
  <UserPromptSource>{jsonPath('$.contents[-1].parts[-1].text',request.content,true)}</UserPromptSource>
  <Identifier ref="request.url"/>
  <Rate>1pm</Rate>
  <UseEffectiveCount>false</UseEffectiveCount>
</PromptTokenLimit>

דוגמה 2

הגבלת טוקנים מבוזרת.

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

<PromptTokenLimit continueOnError="false" enabled="true" name="PTL-limitTokens-1">
  <DisplayName></DisplayName>
  <Properties/>
  <UserPromptSource>{jsonPath('$.contents[-1].parts[-1].text',request.content,true)}</UserPromptSource>
  <Identifier ref="request.url"/>
  <Rate>1pm</Rate>
  <UseEffectiveCount>true</UseEffectiveCount>
</PromptTokenLimit>

דוגמה 3

מגבלת אסימונים של גודל חלון ההקשר לכל בקשה.

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

<PromptTokenLimit continueOnError="false" enabled="true" name="PTL-limitTokens-1">
  <DisplayName></DisplayName>
  <Properties/>
  <UserPromptSource>{jsonPath('$.messages',request.content,true)}</UserPromptSource>
  <Identifier ref="messageid"/>
  <Rate>1pm</Rate>
  <UseEffectiveCount>false</UseEffectiveCount>
</PromptTokenLimit>

דוגמה 4

הגבלת טוקנים מבוזרת עם ערכי ברירת מחדל.

בדוגמה הזו, הגבלת טוקנים של הנחיה מתרחשת בתוך עותק יחיד ולא מופצת בין כמה מעבדי הודעות באזור. המערכת משתמשת בערך ברירת המחדל של מקור ההנחיה למשתמש: {jsonPath('$.messages',request.content,true)}

<PromptTokenLimit continueOnError="false" enabled="true" name="PTL-limitTokens-1">
  <DisplayName></DisplayName>
  <Properties/>
  <Identifier ref="messageid"/>
  <Rate>1pm</Rate>
  <UseEffectiveCount>false</UseEffectiveCount>
</PromptTokenLimit>

הפניה לרכיב צאצא

בקטע הזה מתוארים רכיבי הבן של <PromptTokenLimit>.

<DisplayName>

אפשר להשתמש במאפיין הזה בנוסף למאפיין name כדי לתת למדיניות שם אחר, שנשמע יותר טבעי, ב-UI של עורך ה-proxy לניהול.

הרכיב <DisplayName> משותף לכל סוגי המדיניות.

ערך ברירת המחדל	לא רלוונטי
חובה?	זה שינוי אופציונלי. אם לא מציינים את <DisplayName>, המערכת משתמשת בערך של מאפיין name של המדיניות.
סוג	String
רכיב אב	<PolicyElement>
רכיבי צאצא	ללא

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

תחביר

<PolicyElement>
  <DisplayName>POLICY_DISPLAY_NAME</DisplayName>
  ...
</PolicyElement>

דוגמה

<PolicyElement>
  <DisplayName>My Validation Policy</DisplayName>
</PolicyElement>

לרכיב <DisplayName> אין מאפיינים או רכיבי צאצא.

<Identifier>

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

אם משאירים את הרכיב <Identifier> ריק, תיאכף מגבלת קצב אחת על כל הבקשות ל-proxy ל-API הזה.

ערך ברירת המחדל	לא רלוונטי
חובה?	אופציונלי
סוג	String
רכיב אב	<PromptTokenLimit>
רכיבי צאצא	ללא

תחביר

<PromptTokenLimit
  continueOnError="[false|true]"
  enabled="[true|false]"
  name="POLICY_NAME"
>
  <Identifier ref="FLOW_VARIABLE"/>
</PromptTokenLimit>

דוגמה 1

בדוגמה הבאה מופעלת המדיניות PromptTokenLimit לכל מזהה מפתח:

<PromptTokenLimit name="PTL-limitTokens-1">
  <Identifier ref="developer.id"/>
  <Rate>42pm</Rate/>
  <UseEffectiveCount>true</UseEffectiveCount>
</PromptTokenLimit>
      

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

מאפיין	תיאור	ברירת מחדל	נוכחות
ref	מזהה את המשתנה שלפיו PromptTokenLimit מקבץ בקשות נכנסות. אפשר להשתמש בכל משתנה של זרימת נתונים כדי לציין לקוח ייחודי, כמו המשתנים שזמינים עם מדיניות VerifyAPIKey. אפשר גם להגדיר משתנים מותאמים אישית באמצעות מדיניות JavaScript או מדיניות AssignMessage.	לא רלוונטי	חובה

<Rate>

התנאי הזה מציין את הקצב שבו תוגבל הגבלת קצב של יצירת בקשות (או פרצי) של טוקנים, על ידי הגדרת מספר הטוקנים שמותרים במרווחי זמן של דקה או שנייה. אפשר להשתמש ברכיב הזה בשילוב עם <Identifier> כדי לווסת את תעבורת הנתונים בצורה חלקה בזמן הריצה על ידי קבלת ערכים מהלקוח. משתמשים ברכיב <UseEffectiveCount> כדי להגדיר את אלגוריתם הגבלת הקצב שבו נעשה שימוש במדיניות.

הערה: השימוש ב-<UseEffectiveCount> עם ערך או false לא נתמך באף ארגון Apigee או בארגוני Apigee Hybrid שמריצים עומסי עבודה של ייצור. למידע נוסף, אפשר לעיין במאמר בנושא <UseEffectiveCount>.

ערך ברירת המחדל	לא רלוונטי
חובה?	חובה
סוג	מספר שלם
רכיב אב	<PromptTokenLimit>
רכיבי צאצא	ללא

תחביר

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

• שיעור סטטי שאתם מציינים כגוף של רכיב <Rate>
• ערך משתנה, שאפשר להעביר אותו על ידי הלקוח. צריך לציין את שם משתנה התהליך באמצעות המאפיין ref

<PromptTokenLimit
    continueOnError="[false|true]"
    enabled="[true|false]"
    name="POLICY_NAME"
>
  <Rate ref="FLOW_VARIABLE">RATE[pm|ps]</Rate>
</PromptTokenLimit>

ערכי שיעור תקפים (מוגדרים כערך משתנה או בגוף הרכיב) צריכים להיות בפורמט הבא:

• ‫intps (מספר האסימונים לשנייה, מוחלק למרווחי זמן של אלפיות השנייה)
• ‫intpm (מספר האסימונים לדקה, מוחלק למרווחי שניות)

הערך של int חייב להיות מספר שלם חיובי שגדול מאפס.

דוגמה 1

בדוגמה הבאה, הקצב מוגדר לחמישה אסימונים בשנייה:

<PromptTokenLimit name="PTL-Static-5ps">
  <Rate>5ps</Rate>
  <UseEffectiveCount>false</UseEffectiveCount>
</PromptTokenLimit>
        

המדיניות מחליקה את הקצב לטוקן אחד שמותר כל 200 אלפיות השנייה (1000/5).

דוגמה 2

בדוגמה הבאה, הקצב מוגדר ל-12 אסימונים לדקה:

<PromptTokenLimit name="PTL-Static-12pm">
  <Rate>12pm</Rate>
  <UseEffectiveCount>false</UseEffectiveCount>
</PromptTokenLimit>

בדוגמה הזו, המדיניות מאפשרת שימוש באסימון אחד כל חמש שניות (60/12).

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

מאפיין	תיאור	נוכחות	ברירת מחדל
ref	מזהה משתנה של זרימת נתונים שמציין את הקצב. זה יכול להיות כל משתנה של זרימת נתונים, כמו פרמטר של שאילתת HTTP, כותרת או תוכן של גוף ההודעה, או ערך כמו KVM. מידע נוסף זמין במאמר הפניה למשתנים של זרימת נתונים. אפשר גם להשתמש במשתנים מותאמים אישית באמצעות מדיניות JavaScript או מדיניות AssignMessage. אם מגדירים גם את ref וגם את גוף הרכיב הזה, הערך של ref מוחל ומקבל עדיפות כשמשתנה הזרימה מוגדר בבקשה. (ההפך נכון אם המשתנה שצוין ב-ref לא מוגדר בבקשה). לדוגמה: <Rate ref="request.header.custom_rate">1pm</Rate> בדוגמה הזו, אם הלקוח לא מעביר כותרת custom_rate, הקצב של ה-proxy ל-API הוא טוקן אחד לדקה לכל הלקוחות. אם הלקוח מעביר כותרת custom_rate עם הערך 10ps לכל הלקוחות בשרת ה-proxy – עד לשליחת בקשה ללא הכותרת custom_rate. אתם יכולים להשתמש ב-<Identifier> כדי לקבץ בקשות ולאכוף תעריפים מותאמים אישית עבור סוגים שונים של לקוחות. אם מציינים ערך ל-ref אבל לא מגדירים את התעריף בגוף של רכיב <Rate> והלקוח לא מעביר ערך, המדיניות PromptTokenLimit מחזירה שגיאה.	אופציונלי	לא רלוונטי

בטבלה הבאה מפורטים המאפיינים של Rate שקובעים את ההתנהגות של הגבלת התנועה:

מאפיין	תיאור
messagesPerPeriod	מציין את מספר האסימונים שמותרים בפרק זמן מוגדר. לדוגמה, אם המדיניות מוגדרת ל-10ps (10 אסימונים לשנייה), הערך של messagesPerPeriod יהיה 10.
periodInMicroseconds	הערך הזה מגדיר את תקופת הזמן במיקרו-שניות, שבמהלכה מחושב הערך של messagesPerPeriod. בהגדרה של '10ps', הערך הזה יהיה 1,000,000, ששווה לשנייה אחת.
maxBurstMessageCount	מייצג את המספר המקסימלי של טוקנים שאפשר לאפשר באופן מיידי או בפרק זמן קצר בתחילת מרווח חדש.

הערה: הערכים והחישובים של המאפיינים האלה יכולים להיות מושפעים ממספר המגה-פיקסלים ומההגדרה UseEffectiveCount. לדוגמה, אם הגדרתם שיעור של '10ps' עם 10 נקודות מדידה והאפשרות UseEffectiveCount מופעלת, השיעור בפועל לכל נקודת מדידה הוא 1ps. המאפיינים הפנימיים של ה-MP הספציפי משתנים בהתאם. לדוגמה, אפשר להגדיר את המאפיין messagesPerPeriod לערך 1 ואת המאפיין periodInMicroseconds לערך 1,000,000.

<UseEffectiveCount>

רכיב זה מאפשר לכם לבחור בין אלגוריתמים שונים של PromptTokenLimit על ידי הגדרת הערך ל-true או ל-false, כמו שמוסבר בהמשך:

TRUE

אם המדיניות מוגדרת לערך true, המדיניות PromptTokenLimit מופצת באזור. המשמעות היא שספירת הבקשות מסונכרנת בין מעבדי ההודעות (MPs) באזור. בנוסף, נעשה שימוש באלגוריתם להגבלת קצב של יצירת בקשות של 'חלון נע'. האלגוריתם הזה מספק התנהגות עקבית של הגבלת קצב הבקשות, ולא 'מיישר' את מספר הבקשות הנכנסות שאפשר לשלוח לשרת העורפי. אם נשלחות הרבה בקשות במרווח זמן קצר, הן יאושרו כל עוד הן לא חורגות ממגבלת הקצב שהוגדרה, כפי שמוגדר ברכיב <Rate>. לדוגמה:

<PromptTokenLimit name="Prompt-Token-Limit-1">
  <Rate>12pm</Rate>
  <Identifier ref="client_id" />
  <UseEffectiveCount>true</UseEffectiveCount>
</PromptTokenLimit>

‫false (ברירת מחדל)

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

אין תמיכה בהחלקת שיעורים בארגוני Apigee.

אם המדיניות מוגדרת לערך false (ברירת המחדל), היא משתמשת באלגוריתם של token bucket כדי להחלקת את העליות החדות בשימוש באסימונים. האלגוריתם מחלק את מגבלת הקצב שאתם מציינים למרווחים קטנים יותר. החיסרון בגישה הזו הוא שאסימונים לגיטימיים רבים שמגיעים בפרק זמן קצר עלולים להידחות.

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

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

  לדוגמה, אם מגדירים 30pm, המערכת תבצע החלקה באופן הבא:
  60 שניות (דקה אחת) / 30pm = אינטרוולים של 2 שניות, או טוקן אחד מותר כל 2 שניות. אם יתקבל טוקן שני תוך פחות מ-2 שניות, הפעולה תיכשל. בנוסף, אם תנסו להוסיף את האסימון ה-31 תוך דקה, הפעולה תיכשל.

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

  לדוגמה, אם המגבלה היא 10ps, ההחלקה תתבצע כך:
  1,000 מילישניות (1 שנייה) חלקי 10ps = מרווחים של 100 מילישניות, או טוקן אחד מותר כל 100 מילישניות. אם יונפק אסימון שני תוך 100 אלפיות השנייה, הפעולה תיכשל. בנוסף, אם תנסו לשלוח אסימון 11 בתוך שנייה, הפעולה תיכשל.

הערה: בהחלקת קצב, מספר האסימונים הוא תמיד מספר שלם שגדול מאפס. ההחלקה אף פעם לא כוללת חישובים של חלקי אסימונים.

ערך ברירת המחדל	לא נכון
חובה?	אופציונלי
סוג	בוליאני
רכיב אב	<PromptTokenLimit>
רכיבי צאצא	ללא

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

מאפיין	תיאור	ברירת מחדל	נוכחות
ref	מזהה את המשתנה שמכיל את הערך של <UseEffectiveCount>. יכול להיות שזה יהיה משתנה זרימה כלשהו, כמו פרמטר של שאילתת HTTP, כותרת או תוכן של גוף ההודעה. מידע נוסף זמין במאמר חומר עזר בנושא משתני זרימה. אפשר גם להגדיר משתנים מותאמים אישית באמצעות מדיניות JavaScript או מדיניות AssignMessage.	לא רלוונטי	אופציונלי

<UserPromptSource>

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

תבנית ההודעה צריכה לספק ערך יחיד של טקסט ההנחיה למשתמש.

לדוגמה, {jsonPath('$.contents[-1].parts[-1].text',request.content,true)}.

ערך ברירת המחדל	לא רלוונטי
חובה?	אופציונלי
סוג	String
רכיב אב	<PromptTokenLimit>
רכיבי צאצא	ללא

תחביר

<PromptTokenLimit
    continueOnError="[false|true]"
    enabled="[true|false]"
    name="POLICY_NAME">
  <UserPromptSource>{jsonPath('$.contents[-1].parts[-1].text',request.content,true)}</UserPromptSource>
</PromptTokenLimit>

דוגמה 1

<PromptTokenLimit name="Prompt-Token-Limit-1">
  <UserPromptSource>{jsonPath('$.contents[-1].parts[-1].text',request.content,true)}</UserPromptSource>
</PromptTokenLimit>

<IgnoreUnresolvedVariables>

קובעת אם העיבוד ייפסק כשנתקלים במשתנה לא פתור.

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

ערך ברירת המחדל	לא נכון
חובה?	אופציונלי
סוג	בוליאני
רכיב אב	<PromptTokenLimit>
רכיבי צאצא	ללא

תחביר

<PromptTokenLimit
    continueOnError="[false|true]"
    enabled="[true|false]"
    name="POLICY_NAME">
  <IgnoreUnresolvedVariables>[true|false]</IgnoreUnresolvedVariables>
</PromptTokenLimit>

דוגמה

<PromptTokenLimit name="Prompt-Token-Limit-1">
  <Rate>10ps</Rate>
  <IgnoreUnresolvedVariables>true</IgnoreUnresolvedVariables>
</PromptTokenLimit>

משתנים בתהליך

כשמדיניות PromptTokenLimit מופעלת, משתני הזרימה הבאים מאוכלסים:

משתנה	סוג	הרשאה	תיאור
ratelimit.POLICY_NAME.failed	בוליאני	קריאה בלבד	המשתנה הזה הוא true אם המדיניות נכשלה בביצוע פנימי. אין להשתמש במשתנה הזה כדי לבדוק אם חרגתם ממגבלת הקצב. יכול להיות שהערך שלו יהיה true בעומס גבוה, בגלל העיצוב של המדיניות שמאפשר גישה גם אם היא נכשלת.
ratelimit.POLICY_NAME.resolvedUserPrompt	String	קריאה בלבד	הפונקציה מחזירה את ההנחיה למשתמש שחולצה.
ratelimit.POLICY_NAME.userPromptSource	String	קריאה בלבד	החזרת תבנית ההודעה להנחיית המשתמש שצוינה במדיניות.
ratelimit.POLICY_NAME.userPromptTokenCount	String	קריאה בלבד	הפונקציה מחזירה את מספר הטוקנים של הנחיית המשתמש שחולצה.

מידע נוסף זמין במאמר חומר עזר בנושא משתני זרימה.

הפניה לשגיאה

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

שגיאות זמן ריצה

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

טיפ: רוצה עזרה בפתרון שגיאה? כדי לקבל מידע מפורט על פתרון בעיות, לוחצים על בעמודה 'תיקון'.

קוד תקלה	סטטוס HTTP	תקלה ב-Apigee	מטרה	תיקון
policies.prompttokenlimit.FailedToExtractUserPrompt	400	לא נכון	לא ניתן לחלץ את ההנחיה למשתמש מבקשת ה-API.
policies.prompttokenlimit.PromptTokenLimitViolation	429	לא נכון	הפרה של PromptTokenLimit.
policies.prompttokenlimit.FailedToCalculateUserPromptTokens	500	TRUE	אי אפשר לחשב את מספר הטוקנים בהנחיה למשתמש.

שגיאות בהטמעה

השגיאות האלה יכולות להתרחש כשפורסים שרת proxy שמכיל את המדיניות הזו.

טיפ: רוצה עזרה בפתרון שגיאה? כדי לקבל מידע מפורט לפתרון בעיות, לוחצים על בעמודה 'תיקון'.

קוד תקלה	סטטוס HTTP	תקלה ב-Apigee	מטרה	תיקון
policies.prompttokenlimit.MessageWeightNotSupported	500	לא נכון	המאפיין MessageWeight לא נתמך במדיניות PromptTokenLimit.

משתני תקלות

המשתנים האלה מוגדרים כשמתרחשת שגיאת זמן ריצה. מידע נוסף על שגיאות שקשורות למדיניות

משתנים	כאשר:	דוגמה
ratelimit.policy_name.fault.name	‫fault_name הוא שם התקלה, כפי שמופיע בטבלה שגיאות בזמן ריצה שלמעלה. שם התקלה הוא החלק האחרון של קוד התקלה.	fault.name Matches "PromptTokenLimitViolation"
ratelimit.policy_name.failed	‫policy_name הוא השם שהמשתמש הגדיר למדיניות שגרמה לשגיאה.	ratelimit.PTL-PromptTokenLimitPolicy.failed = true

דוגמה לתגובת שגיאה

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

הערה: כדי לטפל בשגיאות, מומלץ ללכוד את החלק errorcode בתגובת השגיאה. אל תסתמכו על הטקסט ב-faultstring, כי הוא עשוי להשתנות.

{  
   "fault":{  
      "detail":{  
         "errorcode":"policies.prompttokenlimit.PromptTokenLimitViolation"
      },
      "faultstring":"Prompt Token Limit Violation. Allowed rate : MessageRate{capacity=10, period=Minutes}"
   }
}

דוגמה לכלל שגיאה

בדוגמה הבאה מוצג כלל לטיפול בשגיאות שנועד לטפל בשגיאת PromptTokenLimitViolation:

<FaultRules>
    <FaultRule name="Prompt Token Limit Errors">
        <Step>
            <Name>Assign-Message-1</Name>
        </Step>
        <Condition>(fault.name Matches "PromptTokenLimitViolation")</Condition>
    </FaultRule>
</FaultRules>

קוד סטטוס ה-HTTP הנוכחי לחריגה ממגבלת קצב שהוגדרה על ידי מדיניות LLMTokenQuota או PromptTokenLimit הוא 429 (יותר מדי בקשות).

סכימות

כל סוג מדיניות מוגדר על ידי סכימת XML ‏ (.xsd). סכימות מדיניות זמינות ב-GitHub.

נושאים קשורים

• מדיניות LLMTokenQuota: מדיניות LLMTokenQuota, להגבלת השימוש במכסת הטוקנים של התגובה.
• הגבלת קצב של יצירת בקשות לסקירה כללית על הגבלת קצב של יצירת בקשות
• השוואה בין מדיניות הגבלת קצב הבקשות