Files
cp1-agents/mcp-servers/aws-discovery.server.yaml
Jonathan Boniface c14a94f33b
Some checks failed
check agents / check (push) Failing after 12s
Add hyperscaler discovery MCP servers and Well-Architected guidance
azure-discovery, aws-discovery and gcp-discovery collect read-only metadata
on servers, workloads, Kubernetes clusters, networks, data stores, policies
and provider recommendations. Credentials arrive per call from the vault.
Replies are paged, scrubbed of secrets and anonymised, and throttled calls
back off. cloud-knowledge searches each provider's Well-Architected guidance
from fixed lists only, so no customer detail can leave the platform.

Adds shared skills, the render and test tooling, a public Python Dockerfile
until the hardened base image is reachable, the customer access guide, the
implementation plan and the Vault Service platform issue.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-30 20:11:57 +00:00

342 lines
17 KiB
YAML

# Read-only discovery of a customer's AWS estate. Render with scripts/render_mcp_server.py.
# Credentials arrive per call from the Vault Service. Store them per project, never tenant-wide.
server_id: aws-discovery
name: AWS Discovery
description: Read-only discovery of a customer's AWS estate - servers, workloads, Kubernetes clusters, networks,
data stores, policies and Trusted Advisor findings.
version: 0.1.1
port: 8112
verify_tool: aws_check_connection
shared_code:
- _common/tool_support.py
- _common/aws_support.py
extra_requirements:
- boto3==1.43.122
connection_fields:
- name: access_key_id
title: Access key ID
description: The broker identity that assumes the read-only role.
required: true
secret: false
- name: secret_access_key
title: Secret access key
description: The broker identity's secret key.
required: true
secret: true
- name: role_arn
title: Role ARN
description: The customer's read-only role.
required: true
secret: false
- name: external_id
title: External ID
description: The external id on the role's trust policy.
required: true
secret: true
- name: regions
title: Regions
description: Comma-separated regions that may be read. The first is the default.
required: true
secret: false
- name: account_ids
title: Account IDs
description: Comma-separated member accounts that may be read.
required: false
secret: false
- name: member_role_name
title: Member role name
description: The read-only role's name in member accounts.
required: false
secret: false
- name: aggregator_name
title: Config aggregator
description: An AWS Config aggregator for organisation-wide queries.
required: false
secret: false
tools:
- name: aws_check_connection
display_name: Check connection
description: 'Test the stored connection: assume the role and read its identity. Returns no customer data.'
parameters: []
ai_implementation: |
async def aws_check_connection(arguments: Dict[str, Any]) -> Dict[str, Any]:
try:
who = await _aws_call(arguments, "sts", "get_caller_identity")
except Exception as error:
return {"ok": False, "message": _upstream_failed("aws", error)["error"]["message"]}
return {"ok": True, "account": who.get("Account"), "message": "Assumed the read-only role."}
- name: aws_list_accounts
display_name: List accounts
description: List the organisation's accounts or organizational units. Needs the management or a delegated administrator
account.
parameters:
- name: kind
type: string
description: 'One of: accounts, roots.'
required: false
- &id001
name: page_size
type: integer
description: Items per page, up to 200. Default 50.
required: false
- &id002
name: page_token
type: string
description: next_page_token from the previous reply.
required: false
ai_implementation: |
async def aws_list_accounts(arguments: Dict[str, Any]) -> Dict[str, Any]:
kinds = {"accounts": ("organizations", "list_accounts", "Accounts", "NextToken", "NextToken", {}), "roots": ("organizations", "list_roots", "Roots", "NextToken", "NextToken", {})}
return await _aws_kind("aws_list_accounts", arguments, kinds, "accounts")
- name: aws_list_resources
display_name: List resources
description: List resources of one type that AWS Config has recorded.
parameters:
- name: resource_type
type: string
description: A Config type, such as AWS::EC2::Instance.
required: true
- &id003
name: account_id
type: string
description: 'An account from the connection''s list. Default: the connection''s own.'
required: false
- &id004
name: region
type: string
description: 'A region from the connection''s list. Default: the first.'
required: false
- *id001
- *id002
ai_implementation: |
async def aws_list_resources(arguments: Dict[str, Any]) -> Dict[str, Any]:
resource_type = str(arguments.get("resource_type") or "")
if not re.fullmatch(r"AWS::[A-Za-z0-9]+::[A-Za-z0-9]+", resource_type):
return _refuse("invalid_argument", "resource_type must be a Config type, such as AWS::EC2::Instance")
kinds = {"config": ("config", "list_discovered_resources", "resourceIdentifiers", "nextToken", "nextToken", {"resourceType": resource_type})}
return await _aws_kind("aws_list_resources", {**arguments, "kind": "config"}, kinds, "config")
- name: aws_query_resources
display_name: Query resources
description: Run a read-only AWS Config advanced query. Uses the organisation aggregator when the connection names
one.
parameters:
- name: query
type: string
description: A Config SELECT expression.
required: true
- *id003
- *id004
- *id001
- *id002
ai_implementation: |
async def aws_query_resources(arguments: Dict[str, Any]) -> Dict[str, Any]:
query = str(arguments.get("query") or "").strip()
if not query.upper().startswith("SELECT ") or len(query) > 4000:
return _refuse("invalid_argument", "query must be a SELECT, up to 4000 characters")
aggregator = get_connection().get("aggregator_name")
if aggregator:
kinds = {"q": ("config", "select_aggregate_resource_config", "Results", "NextToken", "NextToken", {"Expression": query, "ConfigurationAggregatorName": aggregator})}
else:
kinds = {"q": ("config", "select_resource_config", "Results", "NextToken", "NextToken", {"Expression": query})}
result = await _aws_kind("aws_query_resources", {**arguments, "kind": "q"}, kinds, "q")
if result.get("success"):
result["data"]["items"] = [_scrub(_aws_document(i)) for i in result["data"]["items"]]
return result
- name: aws_get_resource_metadata
display_name: Get resource metadata
description: Read-only provider metadata for one resource, from AWS Config.
parameters:
- name: resource_type
type: string
description: A Config type.
required: true
- name: resource_id
type: string
description: The resource id.
required: true
- name: scope_entry_id
type: string
description: The scope entry this answers, echoed in the reply.
required: false
- *id003
- *id004
ai_implementation: |
async def aws_get_resource_metadata(arguments: Dict[str, Any]) -> Dict[str, Any]:
account, region, refused = _aws_target(arguments)
if refused:
return refused
try:
body = await _aws_call(arguments, "config", "get_resource_config_history", region, resourceType=arguments.get("resource_type"), resourceId=arguments.get("resource_id"), limit=1)
except Exception as error:
return _upstream_failed("aws", error)
items = body.get("configurationItems", [])
if not items:
return _refuse("not_found", "AWS Config holds no record of this resource")
return _one_result("aws", "aws_get_resource_metadata", arguments, _aws_document(items[0]))
- name: aws_list_servers
display_name: List servers
description: List EC2 instances, Auto Scaling groups or EBS volumes.
parameters:
- name: kind
type: string
description: 'One of: instances, auto_scaling_groups, volumes.'
required: false
- *id003
- *id004
- *id001
- *id002
ai_implementation: |
async def aws_list_servers(arguments: Dict[str, Any]) -> Dict[str, Any]:
return await _aws_kind("aws_list_servers", arguments, AWS_SERVERS, "instances")
- name: aws_list_workloads
display_name: List workloads
description: List Lambda functions, ECS clusters, App Runner services or Elastic Beanstalk environments. Environment
variables are removed.
parameters:
- name: kind
type: string
description: 'One of: lambda_functions, ecs_clusters, app_runner_services, elastic_beanstalk_environments.'
required: false
- *id003
- *id004
- *id001
- *id002
ai_implementation: |
async def aws_list_workloads(arguments: Dict[str, Any]) -> Dict[str, Any]:
return await _aws_kind("aws_list_workloads", arguments, AWS_WORKLOADS, "lambda_functions")
- name: aws_list_kubernetes_clusters
display_name: List Kubernetes clusters
description: List EKS clusters with version, node groups and networking. Stops at the cloud control plane.
parameters:
- *id003
- *id004
- *id001
- *id002
ai_implementation: |
async def aws_list_kubernetes_clusters(arguments: Dict[str, Any]) -> Dict[str, Any]:
async def read(name, region):
cluster = (await _aws_call(arguments, "eks", "describe_cluster", region, name=name))["cluster"]
groups = await _aws_call(arguments, "eks", "list_nodegroups", region, clusterName=name)
return {**cluster, "nodegroups": groups.get("nodegroups", [])}
return await _aws_each("aws_list_kubernetes_clusters", arguments, ("eks", "list_clusters", "clusters", "nextToken", "nextToken", {}), read)
- name: aws_get_network_topology
display_name: Get network topology
description: List VPCs, subnets, route tables, security groups, NAT or internet gateways, transit gateways, peerings,
endpoints or load balancers.
parameters:
- name: kind
type: string
description: 'One of: vpcs, subnets, route_tables, security_groups, nat_gateways, internet_gateways, transit_gateways,
vpc_peering, vpc_endpoints, load_balancers.'
required: false
- *id003
- *id004
- *id001
- *id002
ai_implementation: |
async def aws_get_network_topology(arguments: Dict[str, Any]) -> Dict[str, Any]:
return await _aws_kind("aws_get_network_topology", arguments, AWS_NETWORK, "vpcs")
- name: aws_list_data_stores
display_name: List data stores
description: List RDS instances, DynamoDB tables or S3 buckets. Metadata only, never rows or objects.
parameters:
- name: kind
type: string
description: 'One of: rds_instances, dynamodb_tables, s3_buckets.'
required: false
- *id003
- *id004
- *id001
- *id002
ai_implementation: |
async def aws_list_data_stores(arguments: Dict[str, Any]) -> Dict[str, Any]:
return await _aws_kind("aws_list_data_stores", arguments, AWS_DATA, "rds_instances")
- name: aws_list_organization_policies
display_name: List organization policies
description: List Organizations policies with their documents, or Config rule compliance.
parameters:
- name: kind
type: string
description: 'One of: service_control_policies, resource_control_policies, tag_policies, backup_policies, config_rule_compliance.'
required: false
- *id003
- *id004
- *id001
- *id002
ai_implementation: "async def aws_list_organization_policies(arguments: Dict[str, Any]) -> Dict[str, Any]:\n \
\ kind = arguments.get(\"kind\") or \"service_control_policies\"\n if kind == \"config_rule_compliance\"\
:\n kinds = {kind: (\"config\", \"describe_compliance_by_config_rule\", \"ComplianceByConfigRules\",\
\ \"NextToken\", \"NextToken\", {})}\n return await _aws_kind(\"aws_list_organization_policies\", arguments,\
\ kinds, kind)\n if kind not in AWS_ORG_POLICY_TYPES:\n return _refuse(\"unknown_kind\", \"kind must\
\ be one of: \" + \", \".join(AWS_ORG_POLICY_TYPES) + \", config_rule_compliance\")\n \n async def read(entry,\
\ region):\n policy = (await _aws_call(arguments, \"organizations\", \"describe_policy\", region, PolicyId=entry[\"\
Id\"]))[\"Policy\"]\n targets = await _aws_call(arguments, \"organizations\", \"list_targets_for_policy\"\
, region, PolicyId=entry[\"Id\"])\n return {\"policy_id\": entry[\"Id\"], \"name\": entry.get(\"Name\"\
), \"type\": entry.get(\"Type\"), \"layer\": \"organisation\", \"aws_managed\": entry.get(\"AwsManaged\"), \"\
attached_to\": targets.get(\"Targets\", []), \"document\": _aws_document(policy.get(\"Content\"))}\n return\
\ await _aws_each(\"aws_list_organization_policies\", arguments, (\"organizations\", \"list_policies\", \"Policies\"\
, \"NextToken\", \"NextToken\", {\"Filter\": AWS_ORG_POLICY_TYPES[kind]}), read)\n"
- name: aws_list_resource_policies
display_name: List resource policies
description: 'List resource-based policies: S3 buckets, KMS keys, Lambda functions, SQS queues, SNS topics, or
IAM role trust policies. People are anonymised.'
parameters:
- name: kind
type: string
description: 'One of: s3_buckets, kms_keys, lambda_functions, sqs_queues, sns_topics, iam_role_trust.'
required: false
- *id003
- *id004
- *id001
- *id002
ai_implementation: "async def aws_list_resource_policies(arguments: Dict[str, Any]) -> Dict[str, Any]:\n kind\
\ = arguments.get(\"kind\") or \"s3_buckets\"\n \n def shaped(name, document, resource_type):\n \
\ return {\"name\": name, \"type\": resource_type, \"layer\": \"resource\", \"document\": _aws_document(document)}\n\
\ \n async def bucket(entry, region):\n body = await _aws_call(arguments, \"s3\", \"get_bucket_policy\"\
, region, Bucket=entry[\"Name\"])\n return shaped(entry[\"Name\"], body.get(\"Policy\"), \"s3_bucket\"\
)\n \n async def key(entry, region):\n body = await _aws_call(arguments, \"kms\", \"get_key_policy\"\
, region, KeyId=entry[\"KeyId\"], PolicyName=\"default\")\n return shaped(entry[\"KeyId\"], body.get(\"\
Policy\"), \"kms_key\")\n \n async def function(entry, region):\n body = await _aws_call(arguments,\
\ \"lambda\", \"get_policy\", region, FunctionName=entry[\"FunctionName\"])\n return shaped(entry[\"\
FunctionName\"], body.get(\"Policy\"), \"lambda_function\")\n \n async def queue(url, region):\n \
\ body = await _aws_call(arguments, \"sqs\", \"get_queue_attributes\", region, QueueUrl=url, AttributeNames=[\"\
Policy\"])\n return shaped(url, body.get(\"Attributes\", {}).get(\"Policy\"), \"sqs_queue\")\n \n\
\ async def topic(entry, region):\n body = await _aws_call(arguments, \"sns\", \"get_topic_attributes\"\
, region, TopicArn=entry[\"TopicArn\"])\n return shaped(entry[\"TopicArn\"], body.get(\"Attributes\"\
, {}).get(\"Policy\"), \"sns_topic\")\n \n async def role(entry, region):\n return shaped(entry[\"\
RoleName\"], entry.get(\"AssumeRolePolicyDocument\"), \"iam_role_trust\")\n \n kinds = {\"s3_buckets\"\
: ((\"s3\", \"list_buckets\", \"Buckets\", \"ContinuationToken\", \"ContinuationToken\", {}), bucket),\n \
\ \"kms_keys\": ((\"kms\", \"list_keys\", \"Keys\", \"Marker\", \"NextMarker\", {}), key),\n \
\ \"lambda_functions\": ((\"lambda\", \"list_functions\", \"Functions\", \"Marker\", \"NextMarker\", {}),\
\ function),\n \"sqs_queues\": ((\"sqs\", \"list_queues\", \"QueueUrls\", \"NextToken\", \"NextToken\"\
, {}), queue),\n \"sns_topics\": ((\"sns\", \"list_topics\", \"Topics\", \"NextToken\", \"NextToken\"\
, {}), topic),\n \"iam_role_trust\": ((\"iam\", \"list_roles\", \"Roles\", \"Marker\", \"Marker\"\
, {}), role)}\n if kind not in kinds:\n return _refuse(\"unknown_kind\", \"kind must be one of: \"\
\ + \", \".join(kinds))\n return await _aws_each(\"aws_list_resource_policies\", arguments, kinds[kind][0],\
\ kinds[kind][1])\n"
- name: aws_list_recommendations
display_name: List recommendations
description: List Trusted Advisor recommendations, each with a common Well-Architected pillar, or the customer's
existing Well-Architected Tool reviews.
parameters:
- name: kind
type: string
description: 'One of: trusted_advisor, well_architected_reviews.'
required: false
- *id003
- *id004
- *id001
- *id002
ai_implementation: "async def aws_list_recommendations(arguments: Dict[str, Any]) -> Dict[str, Any]:\n kind\
\ = arguments.get(\"kind\") or \"trusted_advisor\"\n if kind == \"well_architected_reviews\":\n async\
\ def read(entry, region):\n lenses = await _aws_call(arguments, \"wellarchitected\", \"list_lens_reviews\"\
, region, WorkloadId=entry[\"WorkloadId\"])\n return {\"workload\": entry, \"lens_reviews\": lenses.get(\"\
LensReviewSummaries\", [])}\n return await _aws_each(\"aws_list_recommendations\", arguments, (\"wellarchitected\"\
, \"list_workloads\", \"WorkloadSummaries\", \"NextToken\", \"NextToken\", {}), read)\n if kind != \"trusted_advisor\"\
:\n return _refuse(\"unknown_kind\", \"kind must be trusted_advisor or well_architected_reviews\")\n\
\ \n async def read(entry, region):\n pillars = entry.get(\"pillars\") or []\n return {**entry,\
\ \"pillar\": [AWS_PILLARS.get(p, \"other\") for p in pillars], \"provider_category\": pillars}\n return\
\ await _aws_each(\"aws_list_recommendations\", arguments, (\"trustedadvisor\", \"list_recommendations\", \"\
recommendationSummaries\", \"nextToken\", \"nextToken\", {}), read)\n"