人工智能

用推送式架构自动更新 AWS Agent Registry

每当发布在 AWS Agent Registry(Amazon Bedrock AgentCore 的一项能力)中的模型上下文协议(MCP)服务器新增工具或更新其架构时,注册表记录也必须随之更新。如果没有自动化的推送式同步,使用方就会获取到过时的元数据。对于跨账户管理多个 MCP 服务器的组织而言,这种同步能在现有的治理工作流内让目录记录保持最新。

在大多数企业部署中,目录的价值取决于其新鲜度。如果开发者在周一部署了新工具,但注册表记录仍反映上周的架构,使用方就会对目录失去信任。过时的元数据会直接降低注册表的可靠性,导致团队无意中基于不准确的信息构建依赖关系。

当工程师向 MCP 服务器添加工具却忘记更新目录时:

  • 使用方会完全错过这项新能力。
  • 应用可能使用过时的架构调用该工具,导致意外的运行时行为或静默的工作流偏差。

在多个团队之间叠加后,这种自动化的缺失会侵蚀对注册表的信任。组织最终会退回到临时性的发现机制,例如硬编码端点、非正式的知识共享和过时的文档。

在本文中,我们概述了一种事件驱动架构,它使用 AWS CloudTrail、Amazon EventBridge 和 AWS Lambda 来自动执行这些更新。

架构概览

以下解决方案将这些服务整合到一个事件驱动的管道中,该管道可检测运行时变更并自动将其同步到注册表。

该架构同时支持多账户和单账户环境:

  • 单账户设置:对于简单的部署,所有组件都位于账户 A 中。由于事件直接在账户 A 内流转,因此不需要跨账户转发设置。
  • 多账户设置:这涉及两个账户,其中账户 B 的运行时事件会被安全地转发到账户 A。
    • 账户 A(注册表账户) 拥有 AWS Agent Registry、Amazon EventBridge 规则、推送同步 Lambda 函数以及 CloudTrail 日志。
    • 账户 B(MCP 服务器账户) 托管 MCP 服务器运行时以及用于身份验证的 Amazon Cognito OAuth 提供程序。

该示例使用两个账户,但你可以将此架构扩展到多个账户,其中账户 A 作为注册表账户,多个类似账户 B 的 AWS 账户用于不同的 MCP 服务器。

下图展示了账户 B 中 MCP 服务器更新的端到端事件流。捕获的事件会被转发到账户 A,在那里由 Lambda 函数查询 MCP 服务器的工具并更新匹配的注册表记录。

Architecture diagram of the end-to-end event flow: an MCP server update in Account B is captured by AWS CloudTrail, forwarded through Amazon EventBridge to a Lambda function in Account A, which queries the MCP server and updates the matching AWS Agent Registry record.

图 1:跨账户 MCP 服务器更新的端到端事件流,从账户 B 中的 CloudTrail 事件到账户 A 中的注册表记录更新。

该架构使用了五项 AWS 服务:

  • AWS CloudTrail 捕获 UpdateAgentRuntime API 调用作为管理事件。
  • Amazon EventBridge 将事件路由到 Lambda 函数,并支持跨账户转发。
  • AWS Lambda 查询 MCP 服务器的当前工具,与注册表进行比对,并在发生变化时更新记录。
  • AWS Agent Registry 将 MCP 服务器记录及其工具架构存储为中央事实来源。
  • AgentCore Identity 是 Amazon Bedrock AgentCore 的一项能力, 安全地代理 OAuth 令牌交换,因此 Lambda 无需存储密钥即可完成身份验证。

工作原理:业务逻辑流程

部署完成后,流水线会运行以下端到端工作流:

  1. 触发:一名开发者 账户 B 更新 MCP 服务器,该服务器会调用 UpdateAgentRuntime Amazon Bedrock AgentCore 中的 API,AWS CloudTrail 会捕获该事件。
  2. 路由:Amazon EventBridge 捕获 CloudTrail 事件并将其转发到位于 账户 A.
  3. 解析:中的同步 Lambda 会 账户 A 从事件负载中提取运行时 Amazon Resource Name(ARN),并动态构造 MCP 服务器的调用 URL。这就是它如何知道 账户 B 进行查询。
  4. 身份验证:Lambda 通过 AgentCore Identity 生成安全的 OAuth 持有者令牌。
  5. 获取:Lambda 调用 MCP 服务器(initialize,然后 tools/list)以获取最新的工具信息。
  6. 同步:Lambda 通过 ARN 找到匹配的注册表记录,评估差异,并在架构发生变化时更新注册表。

此流程假设账户 A 中的 Agent Registry 已包含 MCP 服务器的预注册记录(在初始入门引导期间创建)。本示例中的 Lambda 函数仅更新现有记录,不会生成新记录。

同样的流程也适用于单账户设置,即所有资源(注册表、Lambda、Amazon EventBridge 规则和 MCP 服务器)都位于同一个账户中。在这种情况下,请跳过跨账户转发步骤。事件会在同一账户的 Amazon EventBridge 总线内直接流转。

技术演练

本节将按照架构图所示,讲解以两个账户进行单次 MCP 服务器更新的工作流。

对于每个发出事件的服务器,同一流程都会独立执行。 UpdateAgentRuntime 事件。Lambda 一次处理一个事件,并随 Amazon EventBridge 的调用模型自然扩展。

步骤 1:跨账户设置的事件捕获与路由

当开发者部署或更新 MCP 服务器时, UpdateAgentRuntime API 时,无论是通过 AgentCore CLI(agentcore deploy)或直接调用。

AWS CloudTrail 将此记录为账户 B 中的管理事件,投递延迟约为 5–15 分钟。随后,该事件会被投递到账户 A 的默认 Amazon EventBridge 总线。

对于跨账户设置,账户 B 的 Amazon EventBridge 通过跨账户规则将匹配的事件转发到账户 A 的事件总线。

账户 A 中的 Amazon EventBridge 规则目标会调用同步 Lambda,并将完整的 CloudTrail 事件 JSON 作为输入负载传递。

Amazon EventBridge 规则模式:

{
  "source": ["aws.bedrock-agentcore"],
  "detail-type": ["API Call via AWS CloudTrail"],
  "detail": { "eventName": ["UpdateAgentRuntime"] }
}

步骤 2:提取 MCP 服务器 URL

Lambda 从事件中解析运行时 ARN。它提取托管账户 ID 和 AWS 区域,以动态构造目标 MCP 服务器的 URL 编码调用端点。

# Extract the runtime ARN from the AWS CloudTrail event payload
def _extract_mcp_url(event):
    detail = event.get("detail", {})
    runtime_arn = detail.get("responseElements", {}).get("agentRuntimeArn", "")
    if not runtime_arn:
        return None, None
    # Parse the account ID from the ARN (5th colon-separated segment)
    arn_parts = runtime_arn.split(":")
    account_id = arn_parts[4] if len(arn_parts) > 4 else None
    region = detail.get("awsRegion", "us-west-2")
    # URL-encode the ARN and build the MCP invocation endpoint
    encoded_arn = runtime_arn.replace(":", "%3A").replace("/", "%2F")
    mcp_url = (f"https://bedrock-agentcore.{region}.amazonaws.com"
               f"/runtimes/{encoded_arn}/invocations?qualifier=DEFAULT")
    return mcp_url, account_id

步骤 3:使用 AgentCore Identity 进行安全身份验证

Lambda 使用两步式身份流程进行身份验证。它先用自己的执行身份换取一个临时工作负载令牌。随后,Lambda 通过目标账户的凭证提供程序,用该令牌换取一个限定范围的 OAuth 持有者令牌。

def get_bearer_token(account_id=None):
    """Get OAuth bearer token via AgentCore Identity credential provider.

    Two-step process:
    1. Get a workload access token from AgentCore Identity (identifies this Lambda)
    2. Use it to fetch an OAuth token from the credential provider (M2M flow)

    The credential provider stores the Cognito/OAuth config securely in AgentCore
    Identity, so no client secrets are needed in Lambda env vars.
    """
    acct = account_id or ""
    provider_name = os.environ.get(f"CREDENTIAL_PROVIDER_{acct}") or os.environ.get("CREDENTIAL_PROVIDER", "")
    scope_str = os.environ.get(f"CREDENTIAL_SCOPE_{acct}") or os.environ.get("CREDENTIAL_SCOPE", "")
    scopes = [s.strip() for s in scope_str.split(",") if s.strip()] if scope_str else []
    workload_name = os.environ.get("WORKLOAD_IDENTITY_NAME", "")
    if not provider_name:
        raise ValueError(f"No CREDENTIAL_PROVIDER configured for account {acct}")
    if not workload_name:
        raise ValueError("WORKLOAD_IDENTITY_NAME env var not set")
    region = os.environ.get("AWS_REGION", "us-west-2")
    client = boto3.client("bedrock-agentcore", region_name=region)
    # Step 1: Get workload access token (identifies this Lambda as a trusted workload)
    wat_response = client.get_workload_access_token(
        workloadName=workload_name,
    )
    print(f"Workload access token response keys: {list(wat_response.keys())}")
    workload_token = wat_response.get("workloadAccessToken") or wat_response.get("accessToken", "")
    if not workload_token:
        raise ValueError(f"No access token in workload response: {list(wat_response.keys())}")
    # Step 2: Use workload token to get OAuth token from the credential provider
    response = client.get_resource_oauth2_token(
        workloadIdentityToken=workload_token,
        resourceCredentialProviderName=provider_name,
        oauth2Flow="M2M",
        scopes=scopes,
    )
    return response["accessToken"]

凭证提供程序是按账户配置的(CREDENTIAL_PROVIDER_{ACCT_ID}),因此一个 Lambda 即可跨多个账户对 MCP 服务器进行身份验证。

步骤 4:查询 MCP 服务器

使用标准的 MCP 可流式 HTTP 机制,Lambda 通过一个请求建立活动会话。 initialize 请求。会话激活后,它会调用 tools/list 以获取当前已暴露工具和架构的完整数组。

def call_tools_list(mcp_url, token):
    """Call the MCP server's initialize + tools/list methods and return the result.

    MCP streamable-http requires initialize before tools/list.
    The session_id from initialize is passed to tools/list if the server uses sessions.
    """
    # Validate URL scheme to prevent file:// or custom scheme access
    if not mcp_url.startswith("https://"):
        raise ValueError(f"Only HTTPS URLs are allowed, got: {mcp_url[:50]}")
    # Step 1: Initialize MCP session
    init_payload = {
        "jsonrpc": "2.0",
        "id": "init-1",
        "method": "initialize",
        "params": {
            "protocolVersion": "2025-03-26",
            "capabilities": {},
            "clientInfo": {"name": "tool-sync-lambda", "version": "1.0.0"},
        },
    }
    init_resp = requests.post(
        mcp_url,
        json=init_payload,
        headers=_mcp_headers(token),
        timeout=30,
    )
    init_resp.raise_for_status()
    session_id = init_resp.headers.get("Mcp-Session-Id")
    init_result = _parse_sse_json(init_resp.text)
    print(f"MCP session initialized, session_id={session_id}")
    # Step 2: Call tools/list
    list_payload = {
        "jsonrpc": "2.0",
        "id": "list-1",
        "method": "tools/list",
        "params": {},
    }
    list_resp = requests.post(
        mcp_url,
        json=list_payload,
        headers=_mcp_headers(token, session_id),
        timeout=30,
    )
    list_resp.raise_for_status()
    return _parse_sse_json(list_resp.text)

步骤 5:查找匹配的注册表记录

Lambda 查询中央 Agent Registry 以定位对应的记录。它在 APPROVED 记录中搜索满足以下条件的记录:其 mcpServer.data 包含在记录创建期间嵌入的运行时 ARN(参见部署部分)。

# Decode the runtime ARN from the MCP URL for matching
def _find_record_by_mcp_url(client, registry_id, mcp_url):
    """Search registry records to find one whose server schema contains the runtime ARN.

    Tries three matching strategies:
    1. Decoded ARN (e.g. arn:aws:bedrock-agentcore:...:runtime/TrimMCP-xxx)
    2. URL-encoded ARN (e.g. arn%3Aaws%3Abedrock-agentcore%3A...%2FTrimMCP-xxx)
    3. Full MCP URL match

    Returns:
        (record_id, full_record) tuple. Both None if no match found.
    """
    # Extract the runtime ARN from the MCP URL for matching
    # URL format: .../runtimes/arn%3A...%2Fruntime%2F<id>/invocations...
    # Decode to get: arn:aws:bedrock-agentcore:region:account:runtime/id
    try:
        decoded_url = urllib.parse.unquote(mcp_url)
        # Extract just the runtime path: arn:aws:bedrock-agentcore:...:runtime/xxx
        runtime_marker = "/runtimes/"
        idx = decoded_url.find(runtime_marker)
        if idx >= 0:
            runtime_arn = decoded_url[idx + len(runtime_marker) :].split("/invocations")[0]
        else:
            runtime_arn = None
    except Exception:  # noqa: BLE001
        runtime_arn = None
    records = client.list_registry_records(registryId=registry_id)
    record_list = records.get("registryRecords", [])
    print(f"Found {len(record_list)} registry records")
    for rec in record_list:
        record_id = rec.get("registryRecordId") or rec.get("recordId") or rec.get("id", "")
        record_name = rec.get("name", "?")
        record_status = rec.get("status", "?")
        print(f" Record: {record_id} | {record_name} | status={record_status} | keys={list(rec.keys())}")
        if not record_id:
            print(f" Warning: could not get record ID from: {list(rec.keys())}")
            continue
        if record_status == "DRAFT":
            print(f" Skipping DRAFT record {record_id} ({record_name}) — must be APPROVED first")
            continue
        try:
            full = client.get_registry_record(
                registryId=registry_id,
                recordId=record_id,
            )
            descriptors = full.get("descriptors", {})
            mcp_desc = descriptors.get("mcpServer", {})
            inline = mcp_desc.get("data", "")
            # Match on runtime ARN (decoded or encoded) in the server schema
            if runtime_arn and runtime_arn in inline:
                print(f"Found matching record (by ARN): {record_id} ({rec.get('name', '?')})")
                return record_id, full
            # Also check URL-encoded ARN
            encoded_arn = runtime_arn.replace(":", "%3A").replace("/", "%2F") if runtime_arn else None
            if encoded_arn and encoded_arn in inline:
                print(f"Found matching record (by encoded ARN): {record_id} ({rec.get('name', '?')})")
                return record_id, full
            if mcp_url in inline or urllib.parse.unquote(mcp_url).replace("?qualifier=DEFAULT", "") in inline:
                print(f"Found matching record (by URL): {record_id} ({rec.get('name', '?')})")
                return record_id, full
        except Exception as e:  # noqa: BLE001
            print(f"Error checking record {record_id}: {e}")
            continue
    print(f"No matching record found among {len(record_list)} records.")
    print(f" Looking for runtime ARN: {runtime_arn}")
    print(f" Looking for MCP URL: {mcp_url}")
    return None, None

步骤 6:比对并更新

为尽量减少不必要的写入,工具列表会被规范化(按名称排序,并使用名称 + 描述 + inputSchema 进行比较)。只有在检测到变更时才会触发注册表更新。如果架构不同,Lambda 会记录具体的添加或移除项,并将最新的定义推送到注册表记录。

# Normalize tool definitions for comparison (sort by name, extract key fields)
def _normalize_tools(tools):
    """Normalize tool list for comparison — extract name, description, inputSchema."""
    normalized = []
    for t in sorted(tools, key=lambda x: x.get("name", "")):
        normalized.append(
            {
                "name": t.get("name", ""),
                "description": t.get("description", ""),
                "inputSchema": t.get("inputSchema", {}),
            }
        )
    return normalized

def _normalize_tools(tools):
    """Normalize tool list for comparison — extract name, description, inputSchema."""
    normalized = []
    for t in sorted(tools, key=lambda x: x.get("name", "")):
        normalized.append(
            {
                "name": t.get("name", ""),
                "description": t.get("description", ""),
                "inputSchema": t.get("inputSchema", {}),
            }
        )
    return normalized

def sync_registry_if_changed(mcp_tools, mcp_url):
    """Compare MCP server tools with AWS Agent Registry record tools. Update only if different.

    Steps:
    1. Find the AWS Agent Registry record matching this MCP server's URL
    2. Extract existing tools from the record's tools.inlineContent
    3. Normalize both tool lists (sort by name, compare name/description/inputSchema)
    4. If identical → skip update
    5. If different → log the diff and update the registry record

    Returns:
        dict with 'action' key: 'no_change', 'updated', or 'skipped'
    """
    registry_id = os.environ["REGISTRY_ID"]
    client = _get_registry_client()
    # Find the matching record
    record_id, full_record = _find_record_by_mcp_url(client, registry_id, mcp_url)
    if not record_id:
        print(f"No matching registry record found for {mcp_url}")
        return {"action": "skipped", "reason": "no matching record"}
    # Get current tools from registry
    registry_tools = _get_registry_tools_from_record(full_record)
    # Compare normalized tool lists
    mcp_normalized = _normalize_tools(mcp_tools)
    registry_normalized = _normalize_tools(registry_tools)
    if mcp_normalized == registry_normalized:
        print(f"No change detected. Registry record {record_id} is up to date ({len(registry_tools)} tools).")
        return {
            "action": "no_change",
            "record_id": record_id,
            "tool_count": len(registry_tools),
        }
    # Tools differ — update the registry
    print(f"Change detected! Registry has {len(registry_tools)} tools, MCP server has {len(mcp_tools)} tools.")
    # Log the diff
    mcp_names = {t["name"] for t in mcp_normalized}
    reg_names = {t["name"] for t in registry_normalized}
    added = mcp_names - reg_names
    removed = reg_names - mcp_names
    if added:
        print(f" Added: {added}")
    if removed:
        print(f" Removed: {removed}")
    if not added and not removed:
        print(" Tool definitions changed (same names, different schemas/descriptions)")
    tool_schema_content = json.dumps({"tools": mcp_tools})
    client.update_registry_record(
        registryId=registry_id,
        recordId=record_id,
        descriptors={
            "optionalValue": {
                "mcpServer": {
                    "optionalValue": {
                        "additionalData": {
                            "optionalValue": {
                                "tools": {
                                    "optionalValue": {
                                        "data": {
                                            "optionalValue": tool_schema_content,
                                        },
                                    }
                                }
                            }
                        }
                    }
                }
            }
        },
    )
    print(f"Updated registry record {record_id} in registry {registry_id}")
    return {
        "action": "updated",
        "record_id": record_id,
        "old_count": len(registry_tools),
        "new_count": len(mcp_tools),
    }

治理与审批工作流

AWS Agent Registry 对每条记录强制执行治理生命周期: 草稿 -> 待审批 -> 已批准 (或“已拒绝/已弃用”)。管理员在注册表级别配置审批设置。这些设置控制哪些内容会被发布、由谁审核,以及记录在可被发现之前是否需要人工审批。只有处于“已批准”状态的记录才会通过搜索、目录浏览或注册表的 MCP 端点对使用者可见。

当 Lambda 用新的工具定义更新记录时,该记录会自动恢复为“草稿”状态。使用者仍会看到之前已批准的版本。随后,必须由管理员或负责人批准该更新,新的元数据才能被发现。这样,自动更新就无法绕过组织审查,管理员也能完全控制向使用者公开的内容。

部署

下表概述了自动化流水线中的各个步骤:

步骤 描述
定义配置 区域、Lambda 名称、注册表 ID 和 MCP 服务器 ARN
创建并批准注册表记录 注册 MCP 服务器条目并将其移至 APPROVED 状态
配置 AgentCore Identity 创建工作负载身份和 OAuth2 凭证提供程序
部署 Lambda 函数 创建 IAM 执行角色、打包处理程序、部署函数
创建 Amazon EventBridge 规则 将事件路由到 Lambda UpdateAgentRuntime 将事件路由到 Lambda
跨账号转发(可选) 从远程账户转发运行时事件

前提条件

在部署此解决方案之前,请确认以下各项已就绪:

  • 一个具有创建 Lambda 函数、Amazon EventBridge 规则、AWS Identity and Access Management(IAM)角色和 Agent Registry 资源权限的 AWS 账户。
  • 已配置凭据、可访问示例中所用全部服务的 AWS 命令行界面(AWS CLI)。有关更多信息,请参阅 AWS CLI 入门.
  • Python 3.12 运行时。
  • 一个现有的 AWS Agent Registry,其中至少包含一条 MCP 服务器记录(在初始入门引导期间创建;创建该记录的说明见“部署”部分)。
  • 部署在 Amazon Bedrock AgentCore 运行时上的 MCP 服务器。
  • 为每个 MCP 服务器账户配置的 AgentCore Identity 工作负载身份和 OAuth2 凭证提供程序(参见 示例仓库 (用于设置)。
  • 对于多账户设置,需要在账户 B 和账户 A 之间配置跨账户的 Amazon EventBridge 权限。

组织通常使用多个账户,其中注册表位于一个账户,而 MCP 服务器位于其他账户。本示例概述了多账户场景,您可以按照说明将其转换为单账户场景。

创建注册表记录

在此示例中,在同步管道能够工作之前,必须存在一条注册表记录,并且其服务器架构中显式嵌入了运行时 ARN。您可以使用以下代码创建该注册表记录,并将运行时 ARN 包含在记录的 mcpServer.data 字段。Lambda 正是根据该字段进行匹配,从而将 AWS CloudTrail 事件与记录关联起来:

# The websiteUrl contains the MCP server invocation URL with the encoded
# runtime ARN: this is what the Lambda matches against later.
encoded_arn = MCP_RUNTIME_ARN.replace(":", "%3A").replace("/", "%2F")
mcp_server_url = (
    f"https://bedrock-agentcore.{AWS_REGION}.amazonaws.com"
    f"/runtimes/{encoded_arn}/invocations?qualifier=DEFAULT"
)
server_schema = json.dumps({
    "name": MCP_SERVER_NAME,
    "description": MCP_SERVER_DESCRIPTION,
    "websiteUrl": mcp_server_url,
})
registry_cp.create_registry_record(
    registryId=REGISTRY_ID,
    name=MCP_SERVER_NAME,
    description=MCP_SERVER_DESCRIPTION,
    recordType="MCP",
    recordVersion="1.0",
    descriptors={"mcpServer": {"data": server_schema}}
)

批准记录

Lambda 仅同步到 APPROVED 记录。

进行更新后,注册表记录处于 DRAFT 阶段。它必须经过治理工作流,该变更才能被发现。

# Submit for approval (DRAFT → PENDING_APPROVAL)
registry_cp.submit_registry_record_for_approval(
    registryId=REGISTRY_ID,
    recordId=RECORD_ID,
)
# Approve (PENDING_APPROVAL → APPROVED)
registry_cp.update_registry_record_status(
    registryId=REGISTRY_ID,
    recordId=RECORD_ID,
    status="APPROVED",
)

Lambda 环境变量

为维持强大的安全态势,Lambda 环境变量中不存储任何客户端密钥。该函数完全依赖将环境变量映射到引用运行时工作负载身份、提供方名称和权限范围。

# No client secrets here. Only provider names and scopes.
# The Lambda uses WORKLOAD_IDENTITY_NAME to get a workload token,
# then CREDENTIAL_PROVIDER_{ACCT} to fetch the OAuth token.
env_vars = {
    "REGISTRY_ID": REGISTRY_ID,
    "WORKLOAD_IDENTITY_NAME": WORKLOAD_IDENTITY_NAME,
}
for acct_id, config in ACCOUNT_CONFIGS.items():
    env_vars[f"CREDENTIAL_PROVIDER_{acct_id}"] = config["provider_name"]
    env_vars[f"CREDENTIAL_SCOPE_{acct_id}"] = config.get("scope", "")

Amazon EventBridge 规则

此规则充当管道触发器,监听 UpdateAgentRuntime 本地账户内的管理事件,或来自跨账户 Amazon EventBridge 总线转发器的事件:

# Match UpdateAgentRuntime events from AgentCore.
# Fires when any runtime is created or updated in this account
# (or forwarded from a cross-account EventBridge bus).
event_pattern = {
    "source": ["aws.bedrock-agentcore"],
    "detail-type": ["API Call via AWS CloudTrail"],
    "detail": {"eventName": ["UpdateAgentRuntime"]}
}
events_client.put_rule(
    Name=f"{LAMBDA_NAME}-trigger",
    EventPattern=json.dumps(event_pattern),
    State="ENABLED",
)

清理

为避免持续产生费用,请在完成后删除以下资源:

  • Lambda 函数 – 删除推送同步 Lambda 及其 IAM 执行角色。
  • Amazon EventBridge 规则 – 删除该规则及其 Lambda 目标。
  • AgentCore Identity – 删除工作负载身份和 OAuth2 凭证提供程序。
  • 注册表记录 – 删除或弃用测试 MCP 服务器记录。
  • 注册表 – 如果注册表仅为测试而创建,请将其删除。
  • (多账户) 删除账户 B 中的跨账户 Amazon EventBridge 规则和资源策略。

你可以在示例仓库中找到清理代码。 示例仓库.

已知限制与未来改进

此处概述的示例代码(以及完整示例中的代码)可以通过多种方式进行扩展:

  • 自动注册新的 MCP 服务器 – 目前,必须已经存在一条匹配的注册表记录。未来的一项增强功能可以在首次检测到此前未知的 MCP 服务器时自动创建记录。
  • 手动“强制同步”触发 – 对于时间敏感型部署,通过 Amazon API Gateway 或 CLI 命令进行的按需调用路径可以在常规 CloudTrail 交付流程之外处理变更。
  • 冷启动韧性 – 如果 MCP 服务器处于冷启动状态并返回零个工具,Lambda 目前不会重试。加入指数退避,并在工具数量为零时跳过更新,将提升可靠性。

结论

AWS Agent Registry 为组织提供了一个受治理、可发现的目录,用于管理其 AI 代理和 MCP 服务器。

推送同步 Lambda 模式弥合了新鲜度差距:当检测到服务器变更时,注册表记录会在“已知限制”部分所述约束范围内自动且安全地更新。更新会将记录恢复为 DRAFT 状态,并且必须经过审批工作流后才能再次被发现。

随着你的代理集群从少数几个 MCP 服务器增长到数百个,这种模式能让你的注册表始终作为单一事实来源,保持持续新鲜并经过审核。

开始使用

完整实现(Lambda 代码、部署脚本和架构图)以一份 可直接部署的示例要在你的环境中部署该解决方案,请克隆该 仓库 并按照 README 中的部署步骤操作。


关于作者