[アップデート] AgentCore Gatewayのレート制限をリクエストのヘッダーやボディの値ごとに分けられるようになりました

import boto3

client = boto3.client("bedrock-agentcore-control", region_name="us-east-1")

response = client.create_gateway_rate_limit(
    gatewayIdentifier="<GATEWAY_ID>",
    rateLimitId="per-end-user",
    dimensionKeys=[
        "$.context.iam.principal",
        "$.context.request.body.metadata.user_id",
    ],
    entries=[
        {
            "dimensions": {
                "$.context.iam.principal": "*",
                "$.context.request.body.metadata.user_id": "*",
            },
            "requests": [{"rate": 60, "period": "minute"}],
        },
    ],
)
print(response["rateLimitId"], response["status"])

uv run create_body_limit.py

from call import call
from load import run

run([
    ("user-a（並列5本）", lambda: call(body_extra={"metadata": {"user_id": "user-a"}}), 5, 0),
    ("user-c（2秒に1回）", lambda: call(body_extra={"metadata": {"user_id": "user-c"}}), 1, 2),
])

user-a（並列5本）             200:  81  429:  42
user-c（2秒に1回）            200:  11  429:   0

{"type":"error","error":{"type":"rate_limit_error","message":"Rate limit exceeded","limitKey":"per-end-user","metric":"requests","retryAfter":1.0}}

ValidationException Wildcard '*' may only appear at trailing positions. Found non-wildcard value at position 1 after '*'

import boto3

client = boto3.client("bedrock-agentcore-control", region_name="us-east-1")

response = client.create_gateway_rate_limit(
    gatewayIdentifier="<GATEWAY_ID>",
    rateLimitId="per-workload",
    dimensionKeys=[
        "$.context.request.header.X-Workload",
        "$.context.iam.principal",
    ],
    entries=[
        {
            "dimensions": {
                "$.context.request.header.X-Workload": "batch",
                "$.context.iam.principal": "*",
            },
            "requests": [{"rate": 60, "period": "minute"}],
        },
        {
            "dimensions": {
                "$.context.request.header.X-Workload": "*",
                "$.context.iam.principal": "*",
            },
            "requests": [{"rate": 6000, "period": "minute"}],
        },
    ],
)
print(response["rateLimitId"], response["status"])

from call import call
from load import run

run([
    ("X-Workload: batch", lambda: call({"X-Workload": "batch"}), 3, 0),
    ("x-workload: batch", lambda: call({"x-workload": "batch"}), 3, 0),
    ("X-Workload: Batch", lambda: call({"X-Workload": "Batch"}), 3, 0),
    ("X-Workload: chat", lambda: call({"X-Workload": "chat"}), 3, 0),
    ("（ヘッダーなし）", lambda: call(), 3, 0),
])

X-Workload: batch        200:  36  429:  44
x-workload: batch        200:  37  429:  42
X-Workload: Batch        200:  66  429:   0
X-Workload: chat         200:  64  429:   0
（ヘッダーなし）                 200:  66  429:   0

import json

import boto3
import requests
from botocore.auth import SigV4Auth
from botocore.awsrequest import AWSRequest

GATEWAY_URL = "https://<GATEWAY_ID>.gateway.bedrock-agentcore.us-east-1.amazonaws.com"
credentials = boto3.Session().get_credentials()

def call_openai(body_extra=None):
    body = {
        "model": "openai.gpt-5.6-luna",
        "max_output_tokens": 16,
        "input": "hi",
        **(body_extra or {}),
    }
    req = AWSRequest(
        method="POST",
        url=f"{GATEWAY_URL}/inference/v1/responses",
        data=json.dumps(body),
        headers={"Content-Type": "application/json"},
    )
    SigV4Auth(credentials, "bedrock-agentcore", "us-east-1").add_auth(req)
    res = requests.post(req.url, data=req.body, headers=dict(req.headers))
    return res.status_code, res.text

import boto3

client = boto3.client("bedrock-agentcore-control", region_name="us-east-1")

response = client.create_gateway_rate_limit(
    gatewayIdentifier="<GATEWAY_ID>",
    rateLimitId="per-end-user-openai",
    dimensionKeys=[
        "$.context.iam.principal",
        "$.context.request.body.safety_identifier",
    ],
    entries=[
        {
            "dimensions": {
                "$.context.iam.principal": "*",
                "$.context.request.body.safety_identifier": "*",
            },
            "requests": [{"rate": 60, "period": "minute"}],
        },
    ],
)
print(response["rateLimitId"], response["status"])

from call_openai import call_openai
from load import run

run([
    ("user-a（並列5本）", lambda: call_openai({"safety_identifier": "user-a"}), 5, 0),
    ("user-c（2秒に1回）", lambda: call_openai({"safety_identifier": "user-c"}), 1, 2),
])

user-a（並列5本）             200:  77  429:  51
user-c（2秒に1回）            200:  11  429:   0

from call import call
from load import run

run([
    ("user_id: org/user-a", lambda: call(body_extra={"metadata": {"user_id": "org/user-a"}}), 5, 0),
])

user_id: org/user-a      200: 109  429:   0

import boto3

client = boto3.client("bedrock-agentcore-control", region_name="us-east-1")

client.create_gateway_rate_limit(
    gatewayIdentifier="<GATEWAY_ID>",
    rateLimitId="per-caller",
    dimensionKeys=["$.context.iam.principal"],
    entries=[
        {
            "dimensions": {"$.context.iam.principal": "*"},
            "requests": [{"rate": 60, "period": "minute"}],
        },
    ],
)

import itertools
import json
import threading
import time
from collections import Counter
from concurrent.futures import ThreadPoolExecutor

from call import call

counter = itertools.count()
counts = Counter()
lock = threading.Lock()

def worker(seconds=40):
    end = time.time() + seconds
    while time.time() < end:
        # 呼び出すたびに別の利用者IDにする
        status, text = call(body_extra={"metadata": {"user_id": f"user-{next(counter)}"}})
        limit_key = json.loads(text)["error"]["limitKey"] if status == 429 else "-"
        with lock:
            counts[(status, limit_key)] += 1

with ThreadPoolExecutor(max_workers=5) as executor:
    for _ in range(5):
        executor.submit(worker)

for (status, limit_key), n in sorted(counts.items()):
    print(f"{status} limitKey={limit_key}: {n}")

200 limitKey=-: 73
429 limitKey=per-caller: 52

import boto3

client = boto3.client("bedrock-agentcore-control", region_name="us-east-1")
ENGINE_ID = "<ENGINE_ID>"
GATEWAY_ARN = "<GATEWAY_ARN>"

policies = {
    # ENFORCEモードはデフォルト拒否なので、まず全許可を入れる
    "allow_all": f'permit (principal, action, resource == AgentCore::Gateway::"{GATEWAY_ARN}");',
    # userが入っていないChat Completionsのリクエストを拒否する
    "require_user": (
        'forbid (principal, action == AgentCore::Action::"bedrock-mantle___POST:/v1/chat/completions", '
        f'resource == AgentCore::Gateway::"{GATEWAY_ARN}")\n'
        "unless { context.input has user };"
    ),
}
for name, statement in policies.items():
    client.create_policy(
        policyEngineId=ENGINE_ID,
        name=name,
        definition={"cedar": {"statement": statement}},
        validationMode="IGNORE_ALL_FINDINGS",
    )

user 200
no user 403 {"error":{"message":"Request Denied: Gateway Target request not allowed due to policy enforcement [Policy evaluation denied due to require_user-djgb74zm3l]","type":"permission_error","code":"403"}}

body-only -> ValidationException Custom request header/body dimensions require an IAM co-dimension in the same rate limit
header-only -> ValidationException Custom request header/body dimensions require an IAM co-dimension in the same rate limit

import sys
import time

import boto3

region, gw = sys.argv[1], sys.argv[2]
client = boto3.client("bedrock-agentcore-control", region_name=region)

for rate_limit in client.list_gateway_rate_limits(gatewayIdentifier=gw)["rateLimits"]:
    client.delete_gateway_rate_limit(gatewayIdentifier=gw, rateLimitId=rate_limit["rateLimitId"])

for target in client.list_gateway_targets(gatewayIdentifier=gw)["items"]:
    client.delete_gateway_target(gatewayIdentifier=gw, targetId=target["targetId"])

while client.list_gateway_targets(gatewayIdentifier=gw)["items"]:
    time.sleep(5)
client.delete_gateway(gatewayIdentifier=gw)

uv run cleanup.py us-east-1 <GATEWAY_ID>

import time

import boto3

client = boto3.client("bedrock-agentcore-control", region_name="us-east-1")
ENGINE_ID = "<ENGINE_ID>"

for policy in client.list_policies(policyEngineId=ENGINE_ID)["policies"]:
    client.delete_policy(policyEngineId=ENGINE_ID, policyId=policy["policyId"])

while client.list_policies(policyEngineId=ENGINE_ID)["policies"]:
    time.sleep(5)
client.delete_policy_engine(policyEngineId=ENGINE_ID)