LLMTokenQuota 政策

本页面适用于 Apigee，但不适用于 Apigee Hybrid。

查看 Apigee Edge 文档。

概览

LLMTokenQuota 政策旨在管理和控制 AI/LLM 工作负载的令牌消耗。由于大语言模型 (LLM) 互动是基于令牌的，因此有效管理对于控制成本、优化性能和确保平台稳定性至关重要。

配额是 API 代理在某个时间段（例如分钟、小时、天、周或月）内允许使用的 LLM 令牌（输入或输出）配额。LLMTokenQuota 政策会维护计数器，记录 API 代理消耗的令牌数量。借助此功能，API 提供方可以在某个时间段内对应用的令牌消耗量强制执行限制。

此政策使用 <LLMTokenUsageSource> 和 <LLMModelSource> 元素从 LLM 的响应中提取 token 数量，并从请求或响应中提取模型名称，从而实现精确的实时配额强制执行。

此政策是一项可扩展政策，使用此政策可能会影响费用或使用情况，具体取决于您的 Apigee 许可。如需了解政策类型和使用情况影响，请参阅政策类型。

LLMTokenQuota 强制执行机制

下面介绍了 LLMTokenQuota 政策的功能：

token 计数 (<CountOnly>)： LLMTokenQuota 政策会维护计数器，用于跟踪通过 API 代理的 LLM 响应所消耗的 token 数量。
强制执行限制 (<EnforceOnly>)：借助此功能，API 提供商可以严格限制应用在指定时间段内消耗的令牌数量。例如，您可以将应用限制为每分钟 1,000 个令牌或每月 1,000 万个令牌。
超出配额：当 API 代理达到其定义的令牌配额限制时，Apigee 会拒绝后续的令牌消耗请求。系统会返回一条错误消息，直到 LLMTokenQuota 计数器在指定时间间隔结束时自动重置。例如，如果配额设置为每月 10,000 个 token，那么无论在当月的何时达到该限制，系统都会在统计到第 10,000 个 token 时开始限制 token 数。

LLMTokenQuota 如何与 API 产品搭配使用

下文介绍了 LLMTokenQuota 政策如何与 API 产品搭配使用：

在 API 代理（代理或目标无关紧要）的请求中应用 VerifyAPIKey 或 VerifyAccessToken 政策以及 LLMTokenQuota 强制执行政策。
在响应 API 代理（代理或目标无关紧要）时应用 LLMTokenQuota 计数政策。
VerifyAPIKey 或 VerifyAccessToken 政策会将密钥或令牌与 API 产品、操作集、开发者和应用进行匹配。它会针对匹配的 LLM 操作集中的所有模型公开 LLM 配额的流变量。
在配额强制执行政策中，我们根据提供的消息模板提取模型。
然后，系统会匹配相应模型的 LLM 配额变量。如果找到匹配项，则注入引用。
注入引用后，这些值将用于执行配额操作。

LLMTokenQuota 如何与 SSE 响应搭配使用

为了使 LLMTokenQuota 能够与 SSE 响应搭配使用，请将该政策添加为事件流的一部分，如下所示：

<EventFlow content-type="text/event-stream">
    <Response>
      <Step>
        <Name>LLM_TOKEN_QUOTA_COUNT_POLICY_NAME</Name>
      </Step>
    </Response>
  </EventFlow>

在处理事件流时，仅当在事件中找到 LLM 回答中的 token 使用情况元数据时，才会执行 token 计数。当发现令牌使用情况元数据时，系统会提取该元数据并执行政策。对于所有其他事件，相应政策会产生 NO-OP 结果。

LLMTokenQuota 政策类型

LLMTokenQuota 政策支持使用多种不同的方法来启动和重置配额计数器。您可以在 <LLMTokenQuota> 元素中使用 type 属性来定义要使用的方法，如以下示例所示：

<LLMTokenQuota name="LLMTokenQuotaPolicy" type="calendar">
  ...
</LLMTokenQuota>

type 的有效值包括：

calendar：根据显式开始时间配置配额。系统会根据您设置的 <StartTime>、<Interval> 和 <TimeUnit> 值刷新每个应用的 LLMTokenQuota 计数器。
rollingwindow：配置使用滚动窗口确定配额用量的配额。借助 rollingwindow，您可以使用 <Interval> 和 <TimeUnit> 元素确定窗口的大小；例如，1 天。收到请求时，Apigee 会查看请求的确切时间（例如：下午 5:01），并计算自那时到前一天（第一天） 5:01 的令牌消耗量，并确定在该时间段内是否已超出配额。
flexi：配置配额，使计数器在从应用收到第一个请求消息时开始，并根据 <Interval> 和 <TimeUnit> 值重置。

下表介绍了每种类型的配额重置时间：

时间单位	类型
时间单位	`default`（或 null）	`calendar`	`flexi`
分钟	下一分钟开始	比 `<StartTime>` 晚一分钟	发出第一个请求后的 1 分钟
小时	下一小时的顶部	`<StartTime>` 后一小时	发出第一个请求后的一小时
天	当天午夜 (GMT)	比 `<StartTime>` 晚 24 小时	发出第一次请求后的 24 小时
周	当周结束时的 GMT 周日午夜	比 `<StartTime>` 晚一周	发出第一次请求后的一周
月	当月最后一天的午夜 (GMT)	`<StartTime>` 之后的一个月（28 天）	第一个请求之后的一个月（28 天）

对于 type="calendar"，您必须指定 <StartTime> 的值。

该表未说明 rollingwindow 类型的计数的重置时间。这是因为滚动窗口配额的运作方式略有不同，它基于回溯期（例如一小时或一天）。对于 rollingwindow 类型，计数器从不重置，但是会在每个请求重新计算。收到新请求时，政策会确定配额在过去的时间窗口内是否超出配额。

例如，您定义了一个允许 1,000 个令牌的两小时窗口。下午 4:45 收到新请求。该政策计算过去两小时窗口的配额计数，即自下午 2:45 以来的令牌消耗量。如果在两小时窗口内未超过配额限制，则系统会允许该请求。

1 分钟后，即在下午 4:46 收到另一个请求。现在，该政策从下午 2:46 开始计算配额，以确定是否超出限制。

了解配额计数器

当 LLMTokenQuota 政策在 API 代理流中执行时，配额计数器会递增。当计数器达到其限制时，将无法再进行与该计数器关联的任何 API 调用。 LLMTokenQuota 政策可以采用单个计数器，也可以采用多个独立计数器，具体取决于您为 API 产品使用的配置。请务必了解在哪些情况下会使用多个计数器，以及这些计数器的运作方式。

为 API 产品配置配额设置

API 产品可以在产品级别或个别操作级别指定配额设置，也可以同时在这两个级别指定。如果 API 代理包含在 API 产品中，则可以将 LLMTokenQuota 政策配置为使用该产品中定义的配额设置（允许的次数、时间单位和时间间隔）。最简单的方法是通过 useQuotaConfigInAPIProduct 元素来实现。或者，您也可以通过单独的变量引用在 LLMTokenQuota 政策中引用这些设置。

配额的统计方式

默认情况下，Apigee 会为 API 产品中定义的每项操作维护单独的配额计数器，并遵循以下规则：

如果操作定义有配额，则操作的配额设置优先于在产品级别定义的配额设置。
如果操作没有定义配额，则系统会应用产品级别配额设置。
如果 API 产品不包含任何配额设置（无论是在产品级别还是操作级别），则系统会应用 LLMTokenQuota 政策中指定的允许次数、时间单位和时间间隔的配额设置。

在所有情况下，Apigee 都会为 API 产品中定义的每项操作维护单独的配额计数器。与操作匹配的任何 API 调用都会使其计数器递增。

配置 API 代理级别计数器

可以将 API 产品配置为在 API 代理级别维护配额计数。在这种情况下，API 产品级别指定的配额配置会由未指定配额的所有操作共享。此配置会在 API 代理级别为此 API 产品创建一个计数器。

如需实现这种配置，您必须使用 /apiproducts Apigee API 创建或更新产品，并在创建或更新请求中将 quotaCounterScope 属性设置为 PROXY。使用 PROXY 配置时，对于为 API 产品定义的与同一代理关联的所有操作，如果它们没有自己的配额设置，则匹配这些操作的请求将共享该代理的通用配额计数器。

在图 1 中，操作 1 和 2 与 Proxy1 关联，操作 4 和 5 与 Proxy3 关联。由于在 API 产品中设置了 quotaCounterScope=PROXY，因此每项操作都会使用 API 产品级别的配额设置。与 Proxy1 关联的操作 1 和 2 使用共享计数器，而与 Proxy3 关联的操作 4 和 5 使用单独的共享计数器。操作 3 有自己的配额配置设置，因此无论 quotaCounterScope 属性的值是多少，它都会使用自己的计数器。

图 1：quotaCounterScope 标志的使用

如果未使用 API 产品，如何计算配额

如果没有与 API 代理关联的 API 产品，则 LLMTokenQuota 政策会维护单个计数器，无论您在 API 代理中对其引用多少次。配额计数器的名称基于政策的 name 属性。

例如，您创建一个名为 MyLLMTokenQuotaPolicy 的 LLMTokenQuota 政策，限制 5 个令牌，并将其放在 API 代理中的多个流（流 A、B 和 C）中。即使它用于多个流中，也会维护一个由该政策的所有实例更新的单个计数器。假设 LLM 回答每次使用 1 个 token：

执行流 A -> 执行 MyLLMTokenQuotaPolicy，其计数器 = 1
执行流 B -> 执行 MyLLMTokenQuotaPolicy，其计数器 = 2
执行流 A -> 执行 MyLLMTokenQuotaPolicy，其计数器 = 3
执行流 C -> 执行 MyLLMTokenQuotaPolicy，其计数器 = 4
执行流 A -> 执行 MyLLMTokenQuotaPolicy，其计数器 = 5

对其中任何三个流的下一个请求都会被拒绝，因为配额计数器已达到其限制。

在 API 代理流中的多个位置使用同一 LLMTokenQuota 政策，从而可能意外导致 LLMTokenQuota 的运行速度超出您的预期，在反模式简介中对这种反模式进行了说明。

或者，您也可以在 API 代理中定义多个 LLMTokenQuota 政策，并在每个流中使用不同的政策。每个 LLMTokenQuota 政策都根据政策的 name 属性维护自己的计数器。

通过政策配置创建多个计数器

您可以使用 LLMTokenQuota 政策中的 <Class> 或 <Identifier> 元素在单个政策中定义多个唯一计数器。通过使用这些元素，单个政策可以根据发出请求的应用、发出请求的应用开发者、客户端 ID 或其他客户端标识符等，维护不同的计数器。如需详细了解如何使用 <Class> 或 <Identifier> 元素，请参阅上面的示例。

时间表示法

所有 LLMTokenQuota 时间均设置为世界协调时间 (UTC) 时区。

LLMTokenQuota 时间表示法遵循国际标准 ISO 8601 中定义的国际标准日期表示法。

日期采用以下格式定义为年、月和天：YYYY-MM-DD。例如，2025-02-04 表示 2025 年 2 月 4 日。

时间采用以下格式定义为小时、分钟和秒：hours:minutes:seconds。例如，23:59:59 表示午夜前 1 秒的时间。

请注意，您可以使用 00:00:00 和 24:00:00 两种表示法来区分可与一个日期相关联的两个午夜。因此，2025-02-04 24:00:00 是与 2025-02-05 00:00:00 相同的日期和时间。后者通常是首选表示法。

从 API 产品配置获取配额设置

您可以在 API 产品配置中设置配额限制。这些限制不会自动强制执行配额。您可以在 LLMTokenQuota 政策中引用产品配额设置。在产品上设置配额以供 LLMTokenQuota 政策参考具有以下优势：

LLMTokenQuota 政策可以对 API 产品中的所有 API 代理使用统一设置。
您可以对 API 产品的配额设置进行运行时更改，并且引用该值的 LLMTokenQuota 政策会自动更新配额值。

如需详细了解如何使用 API 产品中的配额设置，请参阅动态配额示例。

如需了解如何使用配额限制配置 API 产品，请参阅管理 API 产品。

配置共享配额计数器

在简单情况下，LLMTokenQuota 政策会在初始请求处理期间，针对发送到 API 代理的每个令牌将计数器递增一次。在某些情况下，您可能希望在初始处理传入请求时检查是否超出配额，但仅在处理响应期间递增计数器。

将三个 LLMTokenQuota 政策元素（<SharedName>、<CountOnly> 和 <EnforceOnly>）一起使用时，您可以自定义 LLMTokenQuota 政策，以强制执行传入请求的配额，但仅在响应流程中递增计数器。

例如，假设您有一个使用 LLM 作为目标的 API 代理，并且希望强制执行每小时 10 万个令牌的配额。LLM 回答提供 totalTokenCount 值。如需实现这一点，请执行以下操作：

将 LLMTokenQuota 政策附加到 ProxyEndpoint 请求流，其中 <SharedName> 元素设置名称值，<EnforceOnly> 元素设置为 true。
使用 LLMTokenQuota 政策中的 <LLMTokenUsageSource> 元素来获取 token 数量

有关如何使用共享计数器的示例，请参阅示例部分中的共享计数器。

示例

以下政策代码示例说明了如何通过以下项开始和结束配额周期：

更动态的 LLMTokenQuota

<LLMTokenQuota name="CheckLLMTokenQuota">
  <Interval ref="verifyapikey.verify-api-key.apiproduct.developer.llmquota.interval">1</Interval>
  <TimeUnit ref="verifyapikey.verify-api-key.apiproduct.developer.llmquota.timeunit">hour</TimeUnit>
  <Allow count="200" countRef="verifyapikey.verify-api-key.apiproduct.developer.llmquota.limit"/>
</LLMTokenQuota>

借助动态配额，您可以配置单个 LLMTokenQuota 政策，以便根据传递给 LLMTokenQuota 政策的信息强制执行不同的配额设置。此上下文中 LLMTokenQuota 设置的另一个术语是“服务计划”。动态 LLMTokenQuota 会检查应用的“服务计划”，然后强制执行这些设置。

例如，在创建 API 产品时，您可以选择设置允许的配额限制、时间单位和时间间隔。但是，在 API 产品上设置这些值不会强制在 API 代理中使用它们。此外，您还必须向读取这些值的 API 代理添加 LLMTokenQuota 政策。如需了解详情，请参阅创建 API 产品。

在上面的示例中，包含 LLMTokenQuota 政策的 API 代理使用名为 verify-api-key 的 VerifyAPIKey 政策来验证请求中传递的 API 密钥。接着，LLMTokenQuota 政策会从 VerifyAPIKey 政策访问流变量，以读取 API 产品上设置的配额值。

另一个选项是为各个开发者或应用设置自定义属性，然后在 LLMTokenQuota 政策中读取这些值。例如，要为每个开发者设置不同的配额值，您可以为开发者设置限制、时间单位和间隔等自定义属性。然后，您可以在 LLMTokenQuota 政策中引用这些值，如下所示：

<LLMTokenQuota name="DeveloperLLMTokenQuota">
  <Identifier ref="verifyapikey.verify-api-key.client_id"/>
  <Interval ref="verifyapikey.verify-api-key.developer.timeInterval"/>
  <TimeUnit ref="verifyapikey.verify-api-key.developer.timeUnit"/>
  <Allow countRef="verifyapikey.verify-api-key.developer.limit"/>
</LLMTokenQuota>

此示例还使用 VerifyAPIKey 流变量来引用在开发者上设置的自定义属性。

您可以使用任意变量来设置 LLMTokenQuota 政策的参数。这些变量可以来自：

流变量
关于 API 产品、应用或开发者的属性
键值对映射 (KVM)
标头、查询参数、表单参数等等

对于每个 API 代理，您可以添加一个 LLMTokenQuota 政策来引用与所有其他代理的所有其他 LLMTokenQuota 政策相同的变量，或者 LLMTokenQuota 政策可以引用该政策和代理的唯一变量。

开始时间

<LLMTokenQuota name="LLMTokenQuotaPolicy" type="calendar">
  <StartTime>2025-02-18 10:30:00</StartTime>
  <Interval>5</Interval>
  <TimeUnit>hour</TimeUnit>
  <Allow count="99"/>
</LLMTokenQuota>

对于 type 设置为 calendar 的 LLMTokenQuota，您必须定义一个明确的 <StartTime> 值。时间值为 GMT 时间，而不是本地时间。如果您未为 calendar 类型的政策提供 <StartTime> 值，则 Apigee 会发出错误。

每个应用的 LLMTokenQuota 计数器都将根据 <StartTime>、<Interval> 和 <TimeUnit> 值刷新。在本示例中，LLMTokenQuota 从 GMT 2025 年 2 月 18 日上午 10:30 开始计算，每 5 小时刷新一次。因此，下次刷新时间为 GMT 2025 年 2 月 18 日下午 3:30。

访问计数器

<LLMTokenQuota name="LLMTokenQuotaPolicy">
  <Interval>5</Interval>
  <TimeUnit>hour</TimeUnit>
  <Allow count="99"/>
</LLMTokenQuota>

API 代理可以访问由 LLMTokenQuota 政策设置的流变量。您可以在 API 代理中访问这些流变量以执行条件处理，在接近配额限制时监控政策，将当前配额计数器返回给应用，或出于其他原因。

由于对政策的流变量的访问基于政策 name 属性，因此对于上述名为 <LLMTokenQuota> 的政策，您可以通过以下格式访问其流变量：

ratelimit.LLMTokenQuotaPolicy.allowed.count：允许的计数。
ratelimit.LLMTokenQuotaPolicy.used.count：当前计数器值。
ratelimit.LLMTokenQuotaPolicy.expiry.time：计数器重置的 UTC 时间。

您还可以访问许多其他流变量，如下所述。

例如，您可以使用以下 AssignMessage 政策，将 LLMTokenQuota 流变量的值作为响应标头返回：

<AssignMessage continueOnError="false" enabled="true" name="ReturnQuotaVars">
  <AssignTo createNew="false" type="response"/>
  <Set>
    <Headers>
      <Header name="LLMTokenQuotaLimit">{ratelimit.LLMTokenQuotaPolicy.allowed.count}</Header>
      <Header name="LLMTokenQuotaUsed">{ratelimit.LLMTokenQuotaPolicy.used.count}</Header>
      <Header name="LLMTokenQuotaResetUTC">{ratelimit.LLMTokenQuotaPolicy.expiry.time}</Header>
    </Headers>
  </Set>
  <IgnoreUnresolvedVariables>false</IgnoreUnresolvedVariables>
</AssignMessage>

共享计数器

以下示例说明了如何为 API 代理配置共享计数器，其中目标响应为 HTTP 状态 200 时，配额计数器也会递增。由于两个 LLMTokenQuota 政策使用相同的 <SharedName> 值，因此两个 LLMTokenQuota 政策将共享同一个配额计数器。如需了解详情，请参阅配置共享配额计数器。

ProxyEndpoint 配置示例：

<ProxyEndpoint name="default">
  <PreFlow name="PreFlow">
    <Request>
      <Step>
        <Name>LLMTokenQuota-Enforce-Only</Name>
      </Step>
    </Request>
    <Response>
      <Step>
        <Name>LLMTokenQuota-Count-Only</Name>
      </Step>
    </Response>
    <Response/>
  </PreFlow>
  <Flows/>
  <PostFlow name="PostFlow">
    <Request/>
    <Response/>
  </PostFlow>
  <HTTPProxyConnection>
    <BasePath>/quota-shared-name</BasePath>
  </HTTPProxyConnection>
  <RouteRule name="noroute"/>
</ProxyEndpoint>

第一个 LLMTokenQuota 政策示例：

<LLMTokenQuota name="LLMTokenQuota-Enforce-Only" type="rollingwindow">
  <SharedName>common-counter</SharedName>
  <EnforceOnly>true</EnforceOnly>
  <Allow count="15000"/>
  <Interval>30</Interval>
  <TimeUnit>minute</TimeUnit>
  <Distributed>true</Distributed>
</LLMTokenQuota>

第二个 LLMTokenQuota 政策示例：

<LLMTokenQuota name="LLMTokenQuota-Count-Only" type="rollingwindow">
  <SharedName>common-counter</SharedName>  <!-- Same name as the first LLMTokenQuota policy -->
  <CountOnly>true</CountOnly>
  <Allow count="15000"/>
  <Interval>30</Interval>
  <TimeUnit>minute</TimeUnit>
  <Distributed>true</Distributed>
  <LLMTokenUsageSource>
    {jsonPath('$.usageMetadata.candidatesTokenCount',response.content,true)}
  </LLMTokenUsageSource>
  <LLMModelSource>{jsonPath('$.model',response.content,true)}</LLMModelSource>
</LLMTokenQuota>

第一个请求

<LLMTokenQuota name="MyLLMTokenQuota">
  <Interval>1</Interval>
  <TimeUnit>hour</TimeUnit>
  <Allow count="10000"/>
</LLMTokenQuota>

使用此示例代码，强制执行每小时 10,000 个令牌的配额。该政策会在每个小时的顶部重置配额计数器。如果计数器在一小时结束之前达到 10,000 个令牌的配额，则消耗令牌超过 10,000 个的 API 调用将被拒绝。

例如，如果计数器在 2025-07-08 07:00:00 开始，则会在 2025-07-08 08:00:00（从开始时间算起 1 小时）重置为 0。如果第一个请求是在 2025-07-08 07:35:28 收到的，并且在 2025-07-08 08:00:00 之前词元数达到 10,000，则消耗的词元数超出该计数的请求将被拒绝，直到词元数在小时的顶部重置为止。

计数器重置时间基于 <Interval> 和 <TimeUnit> 的组合。例如，如果将 <Interval> 设置为 12（对于小时的 <TimeUnit>），则计数器会每 12 小时重置一次。您可以将 <TimeUnit> 设置为分钟、小时、天、周或月。

您可以在 API 代理中的多个位置引用此政策。例如，您可以将其放在代理 PreFlow 上，使其针对每个请求执行。或者，您可以将其放在 API 代理的多个流中。如果您在代理的多个位置使用此政策，则该政策会维护一个由该政策的所有实例更新的单个计数器。

或者，您也可以在 API 代理中定义多个 LLMTokenQuota 政策。每个 LLMTokenQuota 政策都根据政策的 name 属性维护自己的计数器。

设置标识符

<LLMTokenQuota name="LLMTokenQuotaPolicy" type="calendar">
  <Identifier ref="request.header.clientId"/>
  <StartTime>2025-02-18 10:00:00</StartTime>
  <Interval>5</Interval>
  <TimeUnit>hour</TimeUnit>
  <Allow count="99"/>
</LLMTokenQuota>

默认情况下，无论请求的来源如何，LLMTokenQuota 政策都会为 API 代理定义一个计数器。或者，您也可以将 <Identifier> 属性与 LLMTokenQuota 政策搭配使用，根据 <Identifier> 属性的值来维护单独的计数器。

例如，使用 <Identifier> 标记为每个客户端 ID 定义单独的计数器。然后，客户端应用会向您的代理请求传递一个包含 clientID 的标头，如上例所示。

您可以为 <Identifier> 属性指定任何流变量。例如，您可以指定名为 id 的查询参数包含唯一标识符：

<Identifier ref="request.queryparam.id"/>

如果您使用 VerifyAPIKey 政策来验证 API 密钥，或将 OAuthV2 政策与 OAuth 令牌搭配使用，则可以使用 API 密钥或令牌中的信息为同一 LLMTokenQuota 政策定义单个计数器。例如，以下 <Identifier> 元素使用名为 verify-api-key 的 VerifyAPIKey 政策的 client_id 流变量：

<Identifier ref="verifyapikey.verify-api-key.client_id"></Identifier>

现在，每个唯一 client_id 值都会在 LLMTokenQuota 政策中定义自己的计数器。

类

<LLMTokenQuota name="LLMTokenQuotaPolicy">
  <Interval>1</Interval>
  <TimeUnit>day</TimeUnit>
  <Allow>
    <Class ref="request.header.developer_segment">
      <Allow class="platinum" count="10000"/>
      <Allow class="silver" count="1000" />
    </Class>
  </Allow>
</LLMTokenQuota>

您可以使用基于类的 LLMTokenQuota 计数来动态设置 LLMTokenQuota 限制。在此示例中，配额限制由随每个请求传递的 developer_segment 标头的值决定。该变量的值可以是 platinum 或 silver。如果标头具有无效值，则该政策会返回配额违规错误。

以下示例展示了 LLMTokenQuota 政策的各种配置。

计算 token 数

此示例展示了如何计算 token。

<LLMTokenQuota name="LTQ-Count-Only" type="rollingwindow">
  <SharedName>common-counter</SharedName>
  <CountOnly>true</CountOnly>
  <Allow count="15000"/>
  <Interval>30</Interval>
  <TimeUnit>minute</TimeUnit>
  <Distributed>true</Distributed>
  <LLMTokenUsageSource>
    {jsonPath('$.usageMetadata.candidatesTokenCount',response.content,true)}
  </LLMTokenUsageSource>
  <LLMModelSource>{jsonPath('$.model',response.content,true)}</LLMModelSource>
</LLMTokenQuota>

使用 API 产品、开发者和应用计算配额动态变量

此示例展示了如何使用 API 产品、开发者和应用来统计配额动态变量。

<LLMTokenQuota name="LTQ-Count-Only" type="rollingwindow">
  <SharedName>common-counter</SharedName>
  <CountOnly>true</CountOnly>
<Interval ref="verifyapikey.verify-api-key.apiproduct.developer.llmQuota.interval">1</Interval>
  <TimeUnit ref="verifyapikey.verify-api-key.apiproduct.developer.llmQuota.timeunit">hour</TimeUnit>
  <Allow count="200" countRef="verifyapikey.verify-api-key.apiproduct.developer.llmQuota.limit"/>
  <Distributed>true</Distributed>
  <LLMTokenUsageSource>
    {jsonPath('$.usageMetadata.candidatesTokenCount',response.content,true)}
  </LLMTokenUsageSource>
  <LLMModelSource>{jsonPath('$.model',response.content,true)}</LLMModelSource>
</LLMTokenQuota>

强制执行没有 API 产品的配额

此示例展示了如何在没有 API 产品的情况下强制执行配额。

<LLMTokenQuota name="Quota-Enforce-Only" type="rollingwindow">
  <SharedName>common-counter</SharedName>
  <EnforceOnly>true</EnforceOnly>
  <Allow count="15000"/>
  <Interval>30</Interval>
  <TimeUnit>minute</TimeUnit>
  <Distributed>true</Distributed>
</LLMTokenQuota>

通过 API 产品、开发者和应用强制执行配额

此示例展示了如何通过 API 产品、开发者和应用强制执行配额。

<LLMTokenQuota name="Quota-Enforce-Only" type="rollingwindow">
  <SharedName>common-counter</SharedName>
  <EnforceOnly>true</EnforceOnly>
<Interval ref="verifyapikey.verify-api-key.apiproduct.developer.llmQuota.interval">1</Interval>
  <TimeUnit ref="verifyapikey.verify-api-key.apiproduct.developer.llmQuota.timeunit">hour</TimeUnit>
  <Allow count="200" countRef="verifyapikey.verify-api-key.apiproduct.developer.llmQuota.limit"/>
  <Distributed>true</Distributed>
</LLMTokenQuota>

使用 SSE 数据流

此示例展示了如何将 LLMTokenQuota 与 SSE 流搭配使用。

token 配额计数政策：

<LLMTokenQuota name="LTQ-Count-Only" type="rollingwindow">
  <SharedName>common-counter</SharedName>
  <CountOnly>true</CountOnly>
  <Allow count="15000"/>
  <Interval>30</Interval>
  <TimeUnit>minute</TimeUnit>
  <Distributed>true</Distributed>
  <LLMTokenUsageSource>
    {jsonPath('$.usageMetadata.candidatesTokenCount',response.content,true)}
  </LLMTokenUsageSource>
  <LLMModelSource>{jsonPath('$.model',response.content,true)}</LLMModelSource>
</LLMTokenQuota>

事件流：

<EventFlow content-type="text/event-stream">
    <Response>
      <Step>
        <Name>LTQ-Count-Only</Name>
      </Step>
    </Response>
  </EventFlow>

`<LLMTokenQuota>` 元素

以下是 <LLMTokenQuota> 的特性和子元素。请注意，某些元素组合相互排斥或不需要。查看特定用法的示例。

使用名为 my-verify-key-policy 的 VerifyAPIKey 政策检查请求中的应用 API 密钥时，默认情况下可以使用以下 verifyapikey.my-verify-key-policy.apiproduct.* 变量。变量值来自与密钥关联的 API 产品的配额设置，如从 API 产品配置获取配额设置中所述。

注意：<LLMTokenQuota> 与标准 <Quota> 政策的不同之处在于，它依赖于令牌使用情况和模型标识的来源，而不是 <MessageWeight> 元素。此外，必须指定 <CountOnly> 或 <EnforceOnly> 元素之一，并将其设置为 true。您不能在同一政策中同时指定这两个元素。

<LLMTokenQuota continueOnError="false" enabled="true" name="LTQ-TokenQuota-1" type="calendar">
  <DisplayName>Quota 3</DisplayName>
  <LLMTokenUsageSource>{jsonPath('$.usageMetadata.candidatesTokenCount',response.content,true)}</LLMTokenUsageSource>
  <LLMModelSource>{jsonPath('$.model',response.content,true)}</LLMModelSource>
  <Allow count="UPPER_REQUEST_LIMIT"
      countRef="verifyapikey.my-verify-key-policy.apiproduct.developer.llmquota.limit"/>
  <Allow>
    <Class ref="request.queryparam.time_variable">
      <Allow class="peak_time" count="UPPER_LIMIT_DURING_PEAK"/>
      <Allow class="off_peak_time" count="UPPER_LIMIT_DURING_OFFPEAK"/>
    </Class>
  </Allow>
  <Interval ref="verifyapikey.my-verify-key-policy.apiproduct.developer.llmquota.interval">
    1
  </Interval>
  <TimeUnit ref="verifyapikey.my-verify-key-policy.apiproduct.developer.llmquota.timeunit">
    month
  </TimeUnit>
  <StartTime>2025-7-16 12:00:00</StartTime>
  <Distributed>false</Distributed>
  <Synchronous>false</Synchronous>
  <AsynchronousConfiguration>
    <SyncIntervalInSeconds>20</SyncIntervalInSeconds>
    <SyncMessageCount>5</SyncMessageCount>
  </AsynchronousConfiguration>
  <Identifier/>
  <IgnoreUnresolvedVariables>false</IgnoreUnresolvedVariables>
  <UseQuotaConfigInAPIProduct>
    <DefaultConfig>
      <Allow>
        <Class ref="request.queryparam.time_variable">
          <Allow class="peak_time" count="5000"/>
          <Allow class="off_peak_time" count="1000"/>
        </Class>
      </Allow>
      <Interval ref="verifyapikey.my-verify-key-policy.apiproduct.developer.llmquota.interval">
        1
      </Interval>
      <TimeUnit ref="verifyapikey.my-verify-key-policy.apiproduct.developer.llmquota.timeunit">
        month
      </TimeUnit>
    </DefaultConfig>
  </UseQuotaConfigInAPIProduct>
  <SharedName/>
  <EnforceOnly>true</EnforceOnly>
</LLMTokenQuota>

以下属性特定于此政策：

属性说明默认值状态

属性	说明	默认值	状态
`type`	设置 LLMTokenQuota 政策类型，用于确定配额计数器检查配额使用量的时间和方式，以及配额的重置方式。如果未设置 `type`，则计数器从分钟/小时/天/周/月开始。有效值包括： `calendar` `rollingwindow` `flexi` 如需查看每种类型的完整说明，请参阅 LLMTokenQuota 政策类型。	不适用	可选

type

设置 LLMTokenQuota 政策类型，用于确定配额计数器检查配额使用量的时间和方式，以及配额的重置方式。

如果未设置 type，则计数器从分钟/小时/天/周/月开始。

有效值包括：

calendar
rollingwindow
flexi

如需查看每种类型的完整说明，请参阅 LLMTokenQuota 政策类型。

不适用

可选

下表介绍了所有政策父元素通用的特性：

属性	说明	默认值	状态
`name`	政策的内部名称。`name` 属性的值可以包含字母、数字、空格、连字符、下划线和英文句点。此值不能超过 255 个字符。（可选）使用 `<DisplayName>` 元素在管理界面代理编辑器中给政策添加不同的自然语言名称标签。	不适用	需要
`continueOnError`	设置为 `false` 可在政策失败时返回错误。这是大多数政策的预期行为。设置为 `true`，即使在政策失败后，仍可以继续执行流。另请参阅：故障规则仅在错误状态下触发（关于 continueOnError）处理当前流中的故障	false	可选
`enabled`	设置为 `true` 可强制执行政策。设为 `false` 可关闭政策。即使政策仍附加到某个流，也不会强制执行该政策。	true	可选
`async`	此特性已弃用。	false	已弃用

<DisplayName> 元素

用于在 name 属性之外在管理界面代理编辑器中给政策添加不同的自然语言名称标签。

<DisplayName>Policy Display Name</DisplayName>

默认

默认	不适用如果省略此元素，则会使用政策的 `name` 属性的值。
状态	可选
类型	字符串

不适用

如果省略此元素，则会使用政策的 name 属性的值。

状态可选

类型字符串

`<Allow>`

指定在指定时间间隔内允许的令牌总数。如果政策的计数器达到此限制值，则后续 API 调用将被拒绝，直到计数器重置。

还可以包含 <Class> 元素，该元素可根据流变量对 <Allow> 元素设置条件。

默认值	不适用
是否必需？	可选
类型	整数或复杂类型
父元素	`<LLMTokenQuota>`
子元素	`<Class>`

下面显示了设置 <Allow> 元素的三种方法：

<Allow count="2000"/>

<Allow countRef="verifyapikey.VerifyAPIKey.apiproduct.developer.llmquota.limit"/>

<Allow count="2000" countRef="verifyapikey.VerifyAPIKey.apiproduct.developer.llmquota.limit"/>

如果您同时指定 count 和 countRef，则 countRef 优先。如果 countRef 在运行时未解析，则使用 count 的值。

您还可以指定 <Class> 元素作为 <Allow> 的子元素，以根据流变量确定政策的允许计数。Apigee 将流变量的值与 <Allow> 元素的 class 属性进行匹配，如下所示：

<Allow>
  <Class ref="request.queryparam.time_variable">
    <Allow class="peak_time" count="5000"/>
    <Allow class="off_peak_time" count="1000"/>
  </Class>
</Allow>

下表列出了 <Allow> 的特性：

属性说明默认值状态

属性	说明	默认值	状态
`count`	用于指定配额的令牌数量。例如，`count` 属性值为 100、`Interval` 为 1，以及月份的 `TimeUnit` 指定配额为每个月 100 个 token。	2000	可选
`countRef`	用于指定包含配额的令牌数量的流变量。`countRef` 优先于 `count` 属性。	无	可选

count

用于指定配额的令牌数量。

例如，count 属性值为 100、Interval 为 1，以及月份的 TimeUnit 指定配额为每个月 100 个 token。

2000

可选

countRef

用于指定包含配额的令牌数量的流变量。countRef 优先于 count 属性。

无

可选

`<Class>`

可让您根据流变量的值对 <Allow> 元素设置条件。对于 <Class> 的每个不同 <Allow> 子标记，该政策会维护不同的计数器。

默认值	不适用
是否必需？	可选
类型	复杂类型
父元素	`<Allow>`
子元素	`<Allow>`（`<Class>` 的子项）

如需使用 <Class> 元素，请使用 <Class> 元素的 ref 属性指定流变量。然后，Apigee 会使用流变量的值选择一个 <Allow> 子元素，以确定政策的允许数量。Apigee 将流变量的值与 <Allow> 元素的 class 属性进行匹配，如下所示：

<Allow>
  <Class ref="request.queryparam.time_variable">
    <Allow class="peak_time" count="5000"/>
    <Allow class="off_peak_time" count="1000"/>
  </Class>
</Allow>

在此示例中，当前配额计数器由随每个请求传递的 time_variable 查询参数的值决定。该变量的值可以是 peak_time 或 off_peak_time。如果查询参数包含无效值，则该政策将返回配额违规错误。

注意：您不能在同一 LLMTokenQuota 政策中同时使用 <Class> 和 <Identifier> 元素。

下表列出了 <Class> 的特性：

属性	说明	默认值	状态
`ref`	用于指定包含配额的配额类的流变量。	无	需要

`<Allow>`（`<Class>` 的子项）

指定 <Class> 元素定义的配额计数器的限制。对于每个 <Class> 不同的 <Allow> 子标记，该政策会维护不同的计数器。

默认值	不适用
是否必需？	可选
类型	复杂类型
父元素	`<Class>`
子元素	无

例如：

    <Allow>
      <Class ref="request.queryparam.time_variable">
        <Allow class="peak_time" count="5000"/>
        <Allow class="off_peak_time" count="1000"/>
      </Class>
    </Allow>

在此示例中，LLMTokenQuota 政策维护名为 peak_time 和 off_peak_time 的两个配额计数器。所使用的计数器取决于传递的查询参数，如 <Class> 示例所示。

下表列出了 <Allow> 的特性：

属性	说明	默认值	状态
`class`	定义配额计数器的名称。	无	必需
`count`	指定计数器的配额限制。	无	必需

<IgnoreUnresolvedVariables>

确定如果 Apigee 无法解析 LLMTokenQuota 政策中 ref 属性引用的变量，是否停止处理该政策。

默认值	false
是否必需？	可选
类型	布尔值
父元素	`<LLMTokenQuota>`
子元素	无

设置为 true 可忽略无法解析的变量并继续处理；否则设置为 false。默认值为 false。

如果 <IgnoreUnresolvedVariables> 设置为 true，并且无法解析 ref 属性中指定的变量，则 Apigee 会忽略 ref 属性。如果包含 ref 属性的元素还包含一个值（例如 <Allow count="2000"/>），则 Apigee 会使用该值。如果没有值，Apigee 会将元素的值视为 null，并替换为默认值（如果有）或空字符串。

如果 <IgnoreUnresolvedVariables> 为 false，并且无法解析 ref 属性中指定的变量，则 Apigee 会返回错误。

`<Interval>`

指定计算配额的时间段数量。

默认值	不适用
是否必需？	必需
类型	整数
父元素	`<LLMTokenQuota>`
子元素	无

用于指定将与您指定的 <TimeUnit>（分钟、小时、天、周或月）配对的整数（例如 1、2、5、60 等），以确定 Apigee 计算配额用量的时间段。

例如，含 hour 的 <TimeUnit> 的间隔 24 表示配额将在 24 小时内计算。

<Interval ref="verifyapikey.VerifyAPIKey.apiproduct.developer.llmquota.interval">1</Interval>

下表列出了 <Interval> 的特性：

属性	说明	默认值	状态
`ref`	用于指定包含配额间隔的流变量。`ref` 优先于显式间隔值。如果同时指定了引用和值，则引用优先。如果 `ref` 在运行时未解析，则使用值。	无	可选

`<TimeUnit>`

指定配额适用的时间单位。

默认值	不适用
是否必需？	必需
类型	字符串
父元素	`<LLMTokenQuota>`
子元素	无

从 minute、hour、day、week、month 或 year 中选择。

注意：LLMTokenQuota 政策还支持 second 作为时间单位。不过，只有非分布式计数器支持 second（当 <Distributed> 设置为 false 时）。Google 建议您使用 PromptTokenLimit 政策来限制第二个级别的请求流量峰值，而不是使用这里的 second 值。

例如，含 hour 的 TimeUnit 的 24 的Interval 表示配额将在 24 小时内计算。

<TimeUnit ref="verifyapikey.VerifyAPIKey.apiproduct.developer.llmquota.timeunit">month</TimeUnit>

下表列出了 <TimeUnit> 的特性：

属性	说明	默认值	状态
`ref`	指定包含配额时间单位的流变量。`ref` 优先于显式间隔值。如果 `ref` 在运行时未解析，则使用此间隔值。	无	可选

`<StartTime>`

将 type 设置为 calendar 时，会指定配额计数器开始计数的日期和时间，而不管是否从任何应用收到任何请求。

默认值	不适用
是否必需？	可选（当 `type` 设为 `calendar` 时必需）
类型	采用 ISO 8601 日期和时间格式的字符串
父元素	`<LLMTokenQuota>`
子元素	无

例如：

<StartTime>2025-7-16 12:00:00</StartTime>

`<Distributed>`

确定 Apigee 使用一个节点还是多个节点来处理请求。

默认值	false
是否必需？	可选
类型	布尔值
父元素	`<LLMTokenQuota>`
子元素	无

设置为 true 指定政策应保留一个中心计数器，并在所有节点中持续对其进行同步。这些节点可以分布在各个可用区和/或区域中。

如果使用 false 的默认值，则您可能会超出配额，因为不共享每个节点的计数：

<Distributed>false</Distributed>

如需保证计数器已同步，并且对每个请求进行更新，请将 <Distributed> 和 <Synchronous> 设置为 true：

<Distributed>true</Distributed>
<Synchronous>true</Synchronous>

`<Synchronous>`

确定是否同步更新分布式配额计数器。

默认值	false
是否必需？	可选
类型	布尔值
父元素	`<LLMTokenQuota>`
子元素	无

设置为 true 可同步更新分布式配额计数器。这意味着对计数器的更新与对 API 的请求检查配额同时进行。如果不允许您通过该配额进行任何 API 调用，则设置为 true。

注意：通过对计数器实现同步更新，存在性能影响和降低吞吐量的风险。在某些情况下，使用 <Synchronous>true</Synchronous> 可能会导致 LLMTokenQuota 政策无法处理某些事务。

设置为 false 可异步更新配额计数器。这意味着，某些超出配额的 API 调用可能会进行，具体取决于何时异步更新中央存储库中的配额计数器。但是，您不会面临与同步更新关联的潜在性能影响。

默认的异步更新间隔为 10 秒。使用 <AsynchronousConfiguration> 元素配置此异步行为。

<Synchronous>false</Synchronous>

`<AsynchronousConfiguration>`

当政策配置元素 <Synchronous> 不存在或存在并设置为 false 时，在分布式配额计数器之间配置同步间隔。当 <Synchronous> 设置为 true 时，Apigee 会忽略此元素。

默认值	不适用
是否必需？	可选
类型	复杂类型
父元素	`<LLMTokenQuota>`
子元素	`<SyncIntervalInSeconds>` `<SyncMessageCount>`

您可以使用 <SyncIntervalInSeconds> 或 <SyncMessageCount> 子元素指定同步行为。使用其中一个或两个元素。例如，

<AsynchronousConfiguration>
   <SyncIntervalInSeconds>20</SyncIntervalInSeconds>
</AsynchronousConfiguration>

或

<AsynchronousConfiguration>
   <SyncIntervalInSeconds>20</SyncIntervalInSeconds>
   <SyncMessageCount>5</SyncMessageCount>
</AsynchronousConfiguration>

如果仅存在 <SyncIntervalInSeconds>，则无论已处理多少条消息，配额都会每 N 秒同步一次，其中 N 是元素中指定的值。
如果仅存在 <SyncMessageCount>，则配额每 M 条消息同步一次（其中 M 是元素中指定的值），或者每 10 秒同步一次（以先到者为准）。
如果这两个元素都存在，则配额每 M 条消息或每 N 秒同步一次（以先到者为准）。
如果不存在 <AsynchronousConfiguration> 或两个子元素都不存在，则无论已处理多少条消息，配额都会每 10 秒同步一次。

`<SyncIntervalInSeconds>`

替换在 10 秒间隔之后执行异步更新的默认行为。

默认值	10 秒
是否必需？	可选
类型	整数
父元素	`<AsynchronousConfiguration>`
子元素	无

<AsynchronousConfiguration>
   <SyncIntervalInSeconds>20</SyncIntervalInSeconds>
</AsynchronousConfiguration>

按照限制中的说明，同步间隔必须大于或等于 10 秒。

`<SyncMessageCount>`

指定在同步配额计数器之前要处理的请求数。

默认值	不适用
是否必需？	可选
类型	整数
父元素	`<AsynchronousConfiguration>`
子元素	无

<AsynchronousConfiguration>
   <SyncMessageCount>5</SyncMessageCount>
</AsynchronousConfiguration>

使用此示例中的配置，在每个节点上，配额计数将在每 5 个请求后或每 10 秒后（以先到者为准）同步一次。

`<LLMTokenUsageSource>`

提供 LLM 回答中 token 使用情况数据的来源。此项必须是解析为单个令牌使用情况值的消息模板。如果政策不属于事件流，并且无法从指定的来源提取令牌数量，则会抛出 policies.ratelimit.FailedToResolveTokenUsageCount 运行时错误。

默认值	{jsonPath('$.usageMetadata.candidatesTokenCount',response.content,true)}
是否必需？	可选
类型	字符串
父元素	`<LLMTokenQuota>`
子元素	无

以下示例展示了如何指定令牌使用情况来源：

<LLMTokenUsageSource>{jsonPath('$.usageMetadata.candidatesTokenCount', response.content, true)}</LLMTokenUsageSource>

`<LLMModelSource>`

提供 LLM 回答或 LLM 请求中模型名称的来源。这必须是一个提供单个模型名称值的消息模板。

默认值
是否必需？	可选
类型	字符串
父元素	`<LLMTokenQuota>`
子元素	无

以下示例展示了如何通过请求指定模型来源：

<LLMModelSource>{jsonPath('$.model', request.content, true)}</LLMModelSource>

`<Identifier>`

配置政策，以便根据流变量创建唯一计数器。

默认值	不适用
是否必需？	可选
类型	字符串
父元素	`<LLMTokenQuota>`
子元素	无

通过标识符元素，您可以将令牌数量分配给由流变量中的值定义的不同存储分区。例如，您可以使用在 VerifyAPIKey 政策后填充的 developer.id 变量，以针对每个特定开发者创建的所有实例强制执行一个配额限制，也可以使用 client_id 针对每个特定应用强制执行配额限制。后者的配置如下所示：

<Identifier ref="client_id"/>

您可以通过引用 AssignMessage 政策或 JavaScript 政策设置的自定义变量，也可以引用隐式设置的变量，例如那些由 VerifyAPIKey 政策或 VerifyJWT 政策设置的变量。如需详细了解变量，请参阅使用流变量；如需查看 Apigee 定义的知名变量列表，请参阅流变量参考文档。

如果您不使用此元素，则政策会将特定 LLMTokenQuota 政策的所有令牌计数分配到一个计数器。

下表介绍 <Identifier> 的特性：

属性说明默认值状态

属性	说明	默认值	状态
`ref`	指定一个流变量来标识要用于请求的计数器。此变量可以引用 HTTP 标头、查询参数、表单参数或消息内容的元素，或某个其他值来标识如何分配令牌数量。 `client_id` 通常用作变量。`client_id` 也称为 API 密钥或使用方密钥，是在 Apigee 中的组织注册应用时为其生成。如果您已为 API 启用 API 密钥或 OAuth 授权政策，则可以使用此标识符。	不适用	可选

ref

指定一个流变量来标识要用于请求的计数器。此变量可以引用 HTTP 标头、查询参数、表单参数或消息内容的元素，或某个其他值来标识如何分配令牌数量。

client_id 通常用作变量。client_id 也称为 API 密钥或使用方密钥，是在 Apigee 中的组织注册应用时为其生成。如果您已为 API 启用 API 密钥或 OAuth 授权政策，则可以使用此标识符。

不适用

可选

`<UseQuotaConfigInAPIProduct>`

定义 API 产品的配额设置，例如时间单位、时间间隔和允许的最大值。

默认值	不适用
是否必需？	可选
类型	复杂类型
父元素	`<LLMTokenQuota>`
子元素	`<DefaultConfig>`

如果您在 LLMTokenQuota 政策中添加 <UseQuotaConfigInAPIProduct> 元素，那么 Apigee 会忽略 LLMTokenQuotaPolicy 的 <Allow>、<Interval> 和 <TimeUnit> 子元素中的任何一个。

<UseQuotaConfigInAPIProduct> 元素只是一个使用 <DefaultConfig> 元素定义的默认设置的容器，如以下示例所示：

<UseQuotaConfigInAPIProduct stepName="POLICY_NAME">
  <DefaultConfig>...</DefaultConfig>
</UseQuotaConfigInAPIProduct>

您可以使用 stepName 属性引用流中的 VerifyAPIKey 政策或 OAuthv2 政策的 ValidateToken 政策操作。

下表介绍 <UseQuotaConfigInAPIProduct> 的特性：

属性	说明	默认值	状态
`stepName`	标识流中身份验证政策的名称。目标可以是 VerifyAPIKey 政策，也可以是 OAuthv2 政策。	不适用	需要

详情请参阅以下内容：

`<DefaultConfig>`

包含 API 产品的配额的默认值。在您定义 <DefaultConfig> 时，这三个子元素都是必需的。

默认值	不适用
是否必需？	可选
类型	复杂类型
父元素	`<UseQuotaConfigInAPIProduct>`
子元素	`<Allow>` `<Interval>` `<TimeUnit>`

您可以在 API 产品的操作中（使用界面或 API 产品 API）以及在 LLMTokenQuota 政策中定义这些值。但是，如果您这么做，则 API 产品上的设置的优先级更高，LLMTokenQuota 政策中的设置将被忽略。

该元素的语法如下：

<UseQuotaConfigInAPIProduct stepName="POLICY_NAME">
  <DefaultConfig>
    <Allow>allow_count</Allow>
    <Interval>interval</Interval>
    <TimeUnit>[minute|hour|day|week|month]</TimeUnit>
  </DefaultConfig>
</UseQuotaConfigInAPIProduct>

以下示例指定了每周的配额为 10000：

<DefaultConfig>
  <Allow>10000</Allow>
  <Interval>1</Interval>
  <TimeUnit>week</TimeUnit>
</DefaultConfig>

详情请参阅以下内容：

`<SharedName>`

将此 LLMTokenQuota 政策标识为共享。API 代理中具有相同 <SharedName> 值的所有 LLMTokenQuota 政策共享相同的底层配额计数器。

如需了解详情和示例，请参阅配置共享配额计数器。

默认值	不适用
是否必需？	可选
类型	字符串
父元素	`<LLMTokenQuota>`
子元素	无

`<CountOnly>`

在 ProxyEndpoint 响应流中的某个步骤中放置一个此元素设置为 true 的 LLMTokenQuota 政策，以跟踪令牌数量，而不会在超出令牌配额限制时向客户端发回错误。如果存在此元素，则还必须存在 <SharedName> 元素，并且不得存在 <EnforceOnly> 元素。

如需了解详情和示例，请参阅配置共享配额计数器。

默认值	false
是否必需？	可选
类型	布尔值
父元素	`<LLMTokenQuota>`
子元素	无

`<EnforceOnly>`

在 API 代理的请求流中放置一个此元素设置为 true 的 LLMTokenQuota 政策，以强制执行令牌限制而不增加配额计数器。如果存在此元素，则还必须存在 <SharedName>，并且不得存在 <CountOnly> 元素。

如需了解详情和示例，请参阅配置共享配额计数器。

默认值	false
是否必需？	可选
类型	布尔值
父元素	`<LLMTokenQuota>`
子元素	无

流变量

当 LLMTokenQuota 政策执行时，会自动填充以下预定义的流变量。如需了解详情，请参阅流变量参考文档。

变量	类型	权限	说明
ratelimit.{policy_name}.allowed.count	长	只读	返回允许的配额计数。
ratelimit.{policy_name}.used.count	长	只读	返回配额间隔内使用的当前配额。
ratelimit.{policy_name}.available.count	长	只读	返回配额间隔内的可用配额计数。
ratelimit.{policy_name}.exceed.count	长	只读	在超出配额后返回 1。
ratelimit.{policy_name}.total.exceed.count	长	只读	在超出配额后返回 1。
ratelimit.{policy_name}.expiry.time	长	只读	返回以毫秒为单位的 UTC 时间，该时间决定了配额何时失效，以及新的配额间隔何时开始。如果 LLMTokenQuota 政策的类型为 `rollingwindow`，则此值无效，因为配额间隔永不失效。
ratelimit.{policy_name}.identifier	字符串	只读	返回附加到政策的（客户端）标识符引用
ratelimit.{policy_name}.class	字符串	只读	返回与客户端标识符关联的类
ratelimit.{policy_name}.class.allowed.count	长	只读	返回类中定义的允许配额计数
ratelimit.{policy_name}.class.used.count	长	只读	返回类中使用的配额
ratelimit.{policy_name}.class.available.count	长	只读	返回类中的可用配额计数
ratelimit.{policy_name}.class.exceed.count	长	只读	返回超出当前配额间隔中类限制的令牌数量
ratelimit.{policy_name}.class.total.exceed.count	长	只读	返回超出所有配额间隔内类限制的令牌总计数，因此它是所有配额间隔的 `class.exceed.count` 总和。
ratelimit.{policy_name}.failed	布尔值	只读	指明政策是否失败（true 或 false）。
llmtokenquota.{policy_name}.model	字符串	只读	返回提取的模型。

错误参考信息

本部分介绍当此政策触发错误时返回的故障代码和错误消息，以及由 Apigee 设置的故障变量。在开发故障规则以处理故障时，请务必了解此信息。如需了解详情，请参阅您需要了解的有关政策错误的信息和处理故障。

运行时错误

政策执行时可能会发生这些错误。

故障代码	HTTP 状态	原因	修复
`policies.llmtokenquota.FailedToResolveModelName`	`400`	无法解析模型名称。	不适用
`policies.llmtokenquota.FailedToResolveTokenUsageCount`	`500`	无法解析 token 使用次数。	不适用
`policies.llmtokenquota.MessageTemplateExtractionFailed`	`400`	消息模板提取失败。	不适用
`policies.llmtokenquota.LLMTokenQuotaViolation`	`429`	LLM token 配额上限已超出。	不适用
`policies.ratelimit.FailedToResolveQuotaIntervalReference`	`500`	如果未在 `LLMTokenQuota` 政策中定义 `<Interval>` 元素，就会出现此错误。此元素是必需的，用于指定 LLM token 配额所适用的时间间隔。时间间隔可以是使用 `<TimeUnit>` 元素定义的分钟、小时、天、周或月。
`policies.ratelimit.FailedToResolveQuotaIntervalTimeUnitReference`	`500`	如果未在 `LLMTokenQuota` 政策中定义 `<TimeUnit>` 元素，就会出现此错误。此元素是必需的，用于指定 LLM token 配额所适用的时间单位。时间间隔可以是分钟、小时、天、周或月。

部署错误

错误名称	原因	修复
`policies.llmtokenquota.MessageWeightNotSupported`	使用“MessageWeight”元素时出错，因为该元素不受支持。	不适用
`policies.llmtokenquota.InvalidConfiguration`	必须将 <CountOnly> 或 <EnforceOnly> 中的一个准确设置为 true。	不适用
`InvalidQuotaInterval`	如果 `<Interval>` 元素中指定的 LLM 令牌配额间隔不是整数，则 API 代理的部署将失败。例如，如果在 `<Interval>` 元素中指定的配额间隔为 0.1，则 API 代理的部署将失败。
`InvalidQuotaTimeUnit`	如果 `<TimeUnit>` 元素中指定的时间单位不受支持，则 API 代理的部署将失败。支持的时间单位包括 `minute`、`hour`、`day`、`week` 和 `month`。
`InvalidQuotaType`	如果 `<LLMTokenQuota>` 元素中的 `type` 属性指定的 LLM 令牌配额类型无效，则 API 代理的部署将失败。支持的配额类型包括 `default`、`calendar`、`flexi` 和 `rollingwindow`。
`InvalidStartTime`	如果 `<StartTime>` 元素中指定的时间格式无效，则 API 代理的部署将失败。有效格式为 `yyyy-MM-dd HH:mm:ss`，这是 ISO 8601 日期和时间格式。例如，如果在 `<StartTime>` 元素中指定的时间为 `7-16-2017 12:00:00`，则 API 代理的部署将失败。
`StartTimeNotSupported`	如果指定的 `<StartTime>` 元素的配额类型不是 `calendar` 类型，则 API 代理的部署将失败。仅 `calendar` 配额类型支持 `<StartTime>` 元素。例如，如果在 `<LLMTokenQuota>` 元素中将 `type` 属性设置为 `flexi` 或 `rolling window`，则 API 代理的部署将失败。
`InvalidSynchronizeIntervalForAsyncConfiguration`	如果在 `LLMTokenQuota` 政策的 `<AsynchronousConfiguration>` 元素中为 `<SyncIntervalInSeconds>` 元素指定的值小于零，则 API 代理的部署将会失败。
`InvalidAsynchronizeConfigurationForSynchronousQuota`	如果将 `LLMTokenQuota` 政策中 `<AsynchronousConfiguration>` 元素的值设置为 `true`，该元素还具有使用 `<AsynchronousConfiguration>` 元素定义的异步配置，则 API 代理的部署将会失败。

故障变量

此政策触发错误时设置这些变量。如需了解详情，请参阅您需要了解的有关政策错误的信息。

变量	其中	示例
`fault.name="fault_name"`	`fault_name` 是故障名称，如上面的运行时错误表中所列。故障名称是故障代码的最后一部分。	`fault.name Matches "LLMTokenQuotaViolation"`
`ratelimit.policy_name.failed`	`policy_name` 是抛出故障的政策的用户指定名称。	`ratelimit.QT-LLMTokenQuotaPolicy.failed = true`

错误响应示例

注意：处理错误时，最佳做法是捕获错误响应的 errorcode 部分。不要依赖 faultstring 中的文本，因为它可能会发生变化。

{  
   "fault":{  
      "detail":{  
         "errorcode":"policies.llmtokenquota.LLMTokenQuotaViolation"
      },
      "faultstring":"Rate limit LLM Token quota violation. Quota limit exceeded.

 Identifier : _default"
   }
}

故障规则示例

<FaultRules>
    <FaultRule name="LLMTokenQuota Errors">
        <Step>
            <Name>JavaScript-1</Name>
            <Condition>(fault.name Matches "LLMTokenQuotaViolation") </Condition>
        </Step>
        <Condition>ratelimit.LLMTokenQuota-1.failed=true</Condition>
    </FaultRule>
</FaultRules>

注意：当传入请求的速率超过 LLMTokenQuota 或 PromptTokenLimit 政策设置的阈值时，系统会返回 HTTP 状态代码 429 Too Many Requests。

LLMTokenQuota 政策 使用集合让一切井井有条 根据您的偏好保存内容并对其进行分类。

概览

LLMTokenQuota 强制执行机制

LLMTokenQuota 如何与 API 产品搭配使用

LLMTokenQuota 如何与 SSE 响应搭配使用

LLMTokenQuota 政策类型

了解配额计数器

为 API 产品配置配额设置

配额的统计方式

配置 API 代理级别计数器

如果未使用 API 产品，如何计算配额

通过政策配置创建多个计数器

时间表示法

从 API 产品配置获取配额设置

配置共享配额计数器

示例

更动态的 LLMTokenQuota

开始时间

访问计数器

共享计数器

第一个请求

设置标识符

类

计算 token 数

使用 API 产品、开发者和应用计算配额动态变量

强制执行没有 API 产品的配额

通过 API 产品、开发者和应用强制执行配额

使用 SSE 数据流

<LLMTokenQuota> 元素

<DisplayName> 元素

<Allow>

<Class>

<Allow>（<Class> 的子项）

<IgnoreUnresolvedVariables>

<Interval>

<TimeUnit>

<StartTime>

<Distributed>

<Synchronous>

<AsynchronousConfiguration>

<SyncIntervalInSeconds>

<SyncMessageCount>

<LLMTokenUsageSource>

<LLMModelSource>

<Identifier>

<UseQuotaConfigInAPIProduct>

<DefaultConfig>

<SharedName>

<CountOnly>

<EnforceOnly>

流变量

错误参考信息

运行时错误

部署错误

故障变量

错误响应示例

故障规则示例

架构

相关主题

LLMTokenQuota 政策

`<LLMTokenQuota>` 元素

`<Allow>`

`<Class>`

`<Allow>`（`<Class>` 的子项）

`<Interval>`

`<TimeUnit>`

`<StartTime>`

`<Distributed>`

`<Synchronous>`

`<AsynchronousConfiguration>`

`<SyncIntervalInSeconds>`

`<SyncMessageCount>`

`<LLMTokenUsageSource>`

`<LLMModelSource>`

`<Identifier>`

`<UseQuotaConfigInAPIProduct>`

`<DefaultConfig>`

`<SharedName>`

`<CountOnly>`

`<EnforceOnly>`