Integrating AWS API MCP Server with Amazon Fast utilizing Amazon Bedrock AgentCore Runtime

As your AWS infrastructure scales, operational workflows naturally develop extra complicated. SREs and DevOps Engineers spend vital time context-switching between the AWS Administration Console, CLI documentation, and a number of service dashboards. They manually translate enterprise questions into the proper API syntax, chain calls throughout companies, and rebuild the identical integration patterns for every new use case.This friction compounds over time. Incident investigations require cross-referencing Amazon CloudWatch Logs, Amazon Elastic Compute Cloud (Amazon EC2) occasion states, and AWS Identification and Entry Administration (IAM) insurance policies throughout separate interfaces. Capability planning means manually querying a number of companies and assembling outcomes. Safety audits demand constant, repeatable API name sequences which can be time-consuming to script from scratch.

This submit exhibits you easy methods to use Amazon Bedrock AgentCore Runtime with Mannequin Context Protocol (MCP) help to attach Amazon Fast with AWS companies via the AWS API MCP Server, making a conversational AI assistant that interprets pure language into AWS Command Line Interface (AWS CLI) instructions, with out the necessity to change between instruments throughout essential moments.

With Amazon Bedrock AgentCore Runtime and MCP help, pure language queries translate on to AWS API calls. You may ask, “Present me all working EC2 situations in us-east-1,” and get rapid, correct outcomes with out switching between instruments or memorizing API syntax. Your requests run securely inside your present IAM permissions, with full Amazon CloudWatch audit trails for compliance. Fairly than rebuilding connection logic for every workflow, you’ll be able to standardize how AI brokers work together with AWS companies via a single, reusable integration. The next diagram exhibits how Amazon Bedrock AgentCore Runtime connects Amazon Fast to AWS companies via the AWS API MCP Server.

The way it works for each day operations:

1. You ask a query in pure language: “Present working EC2 situations in us-east-1”.
2. The Amazon Fast customized agent interprets your intent.
3. Amazon Cognito authenticates the request: Fast obtains a JWT token out of your Amazon Cognito consumer pool utilizing OAuth 2.0 consumer credentials movement with the Consumer ID and Consumer Secret you configured.
4. The agent connects to AWS API MCP Server: The authenticated request reaches Amazon Bedrock AgentCore Runtime, which validates the JWT token in opposition to your Cognito identification supplier configuration.
5. AgentCore Runtime authorizes and routes the request: After validating your Cognito token, AgentCore Runtime securely invokes the AWS API MCP Server working within the containerized atmosphere.
6. The MCP server interprets your request: Your pure language question is transformed into the suitable AWS CLI command.
7. AWS companies execute the command: Utilizing the IAM execution position you configured, the command runs with least-privilege permissions in opposition to AWS companies.
8. Outcomes are returned in a readable format: No CLI syntax required. You get structured, readable outcomes instantly in your Fast interface.

Conditions

You could have the next stipulations to comply with together with this submit.

Account and entry necessities:

• AWS account with administrative entry
• Amazon Fast Enterprise subscription (Skilled tier minimal)
• Entry to AWS Market – AWS API MCP Server
• IAM permissions to create:
  • Amazon Cognito consumer swimming pools
  • IAM roles and insurance policies
  • Amazon Bedrock AgentCore Runtime brokers
  • Amazon CloudWatch Log teams

Required software program and instruments:

• AWS CLI put in and configured (required for the URL encoding step within the walkthrough)

Required data and experience:

• Primary understanding of IAM roles and insurance policies (already listed)
• Familiarity with OAuth 2.0 authentication flows
• Understanding of JWT (JSON Net Token) ideas

Extra data:

• Estimated completion time: 30–45 minutes
• Estimated month-to-month price: For a single Enterprise consumer working roughly 500 queries per thirty days, the estimated price is roughly $292/month, primarily pushed by the Amazon Fast Enterprise subscription ($40/consumer/month) and infrastructure charge ($250/account/month).

Arrange the answer

Guide deployment

To implement the answer, full the next steps:

1. Arrange an Amazon Cognito consumer pool – For authentication.
2. Create IAM roles – For authorization.
3. Create an Amazon Bedrock AgentCore Runtime agent.
4. Configure Integrations in Amazon Fast for AWS API MCP Server.
5. Create a customized chat agent in Amazon Fast.

Visible layouts in some screenshots on this submit may look totally different than these in your AWS Administration Console.

Arrange Amazon Cognito consumer pool

Amazon Cognito offers authentication and authorization in your utility. On this resolution, you configure a Cognito consumer pool to generate JWT tokens that authenticate requests to the Amazon Bedrock AgentCore Runtime. With JWT authentication utilizing Amazon Cognito, you configure the authorizer in the course of the CreateAgentRuntime operation, specifying your identification supplier (IdP)-specific discovery URL and allowed shoppers. Your present agent code requires no modification. You add the authorizer configuration to your runtime deployment. When a calling entity or consumer invokes your agent, they move their IdP-specific entry token as a bearer token within the Authorization header. AgentCore Runtime makes use of AgentCore Identification to mechanically validate this token in opposition to your configured authorizer and rejects unauthorized requests.

Create Amazon Cognito consumer pool for JWT authentication with distinctive utility title and utility kind as Machine-to-machine utility as proven within the following screenshot. Present a reputation for the applying after which select create consumer listing.

If you create a Cognito consumer pool with a machine-to-machine utility, Amazon Cognito mechanically creates a useful resource server in your utility. The useful resource server defines customized OAuth 2.0 scopes that specify the permissions your utility can request

From the newly created consumer pool menu, navigate to Branding and select Area. Choose the Useful resource server created and select edit. Add write scope to the customized scope and replace the descriptions for each learn and write.

The learn and write scopes management entry to the AWS API MCP Server:

• Learn scope – Permits the applying to question AWS assets (for instance, itemizing EC2 situations or describing Amazon Easy Storage Service (Amazon S3) buckets).
• Write scope – Permits the applying to change AWS assets (for instance, creating assets or updating configurations).

These scopes map to the IAM permissions that the MCP server makes use of when executing AWS CLI instructions on behalf of authenticated requests.

Create IAM roles

To run brokers or instruments in Amazon Bedrock AgentCore Runtime, you want an IAM execution position. For details about creating an IAM position, see IAM position creation.

Create the required belief coverage and execution position for Amazon Bedrock AgentCore Runtime. See IAM Permissions for AgentCore Runtime for extra particulars. Change YOUR_ACCOUNR_ID beneath together with your AWS account ID.

The next code is for the AgentCore Runtime belief coverage:

{
  "Model": "2012-10-17",
  "Assertion": [
    {
      "Sid": "AssumeRolePolicy",
      "Effect": "Allow",
      "Principal": {
        "Service": "bedrock-agentcore.amazonaws.com"
      },
      "Action": "sts:AssumeRole",
      "Condition": {
        "StringEquals": {
          "aws:SourceAccount": "YOUR_ACCOUNT_ID"
        },
        "ArnLike": {
          "aws:SourceArn": "arn:aws:bedrock-agentcore:*:YOUR_ACCOUNT_ID:*"
        }
      }
    }
  ]
}

The next code is for the AgentCore Runtime execution position:

The next IAM coverage grants your execution position the permissions required to drag the AWS API MCP Server container picture and write runtime logs. The container picture is hosted in an AWS-managed public Amazon Elastic Container Registry (Amazon ECR) repository. You don’t have to construct or preserve the picture your self.

To search out the newest container URI, go to : AWS Market – AWS API MCP Server.

{
    "Model": "2012-10-17",
    "Assertion": [
        {
            "Sid": "ECRImageAccess",
            "Effect": "Allow",
            "Action": [
                "ecr:BatchGetImage",
                "ecr:GetDownloadUrlForLayer"
            ],
            "Useful resource": [
                "arn:aws:ecr:us-east-1:709825985650:repository/*"
            ]
        },
        {
            "Impact": "Enable",
            "Motion": [
                "logs:DescribeLogStreams",
                "logs:CreateLogGroup"
            ],
            "Useful resource": [
                "arn:aws:logs:us-east-1:YOUR_ACCOUNT_ID:log-group:/aws/bedrock-agentcore/runtimes/*"
            ]
        },
        {
            "Impact": "Enable",
            "Motion": [
                "logs:DescribeLogGroups"
            ],
            "Useful resource": [
                "arn:aws:logs:us-east-1:YOUR_ACCOUNT_ID:log-group:*"
            ]
        },
        {
            "Impact": "Enable",
            "Motion": [
                "logs:CreateLogStream",
                "logs:PutLogEvents"
            ],
            "Useful resource": [
                "arn:aws:logs:us-east-1:YOUR_ACCOUNT_ID:log-group:/aws/bedrock-agentcore/runtimes/*:log-stream:*"
            ]
        },
        {
            "Sid": "ECRTokenAccess",
            "Impact": "Enable",
            "Motion": [
                "ecr:GetAuthorizationToken"
            ],
            "Useful resource": "*"
        },
        {
            "Impact": "Enable",
            "Motion": [
                "xray:PutTraceSegments",
                "xray:PutTelemetryRecords",
                "xray:GetSamplingRules",
                "xray:GetSamplingTargets"
            ],
            "Useful resource": [ "*" ]
        },
        {
            "Impact": "Enable",
            "Useful resource": "*",
            "Motion": "cloudwatch:PutMetricData",
            "Situation": {
                "StringEquals": {
                    "cloudwatch:namespace": "bedrock-agentcore"
                }
            }
        },
        {
            "Sid": "GetAgentAccessToken",
            "Impact": "Enable",
            "Motion": [
                "bedrock-agentcore:GetWorkloadAccessToken",
                "bedrock-agentcore:GetWorkloadAccessTokenForJWT",
                "bedrock-agentcore:GetWorkloadAccessTokenForUserId"
            ],
            "Useful resource": [
              "arn:aws:bedrock-agentcore:us-east-1:YOUR_ACCOUNT_ID:workload-identity-directory/default",
              "arn:aws:bedrock-agentcore:us-east-1:YOUR_ACCOUNT_ID:workload-identity-directory/default/workload-identity/*"
            ]
        }
    ]
}

Connect particular permissions to the position that outline what actions it will probably carry out in your behalf. This instance makes use of a scoped-down read-only coverage granting s3:ListBucket and s3:GetObject throughout all buckets. That is deliberately broad for discovery and exploration functions solely.

Observe: Utilizing a wildcard useful resource (arn:aws:s3:::*) grants entry to each S3 bucket in your account. That is acceptable for preliminary setup and testing however violates the precept of least privilege in manufacturing. Earlier than deploying to manufacturing, exchange the wildcard with particular bucket ARNs:

"Useful resource": [
"arn:aws:s3:::your-specific-bucket",
"arn:aws:s3:::your-specific-bucket/*"
]

Instance Function:

{
  "Model": "2012-10-17",
  "Assertion": [
    {
      "Effect": "Allow",
      "Action": [
        "s3:ListBucket",
        "s3:GetObject"
      ],
      "Useful resource": [
        "arn:aws:s3:::*"
      ]
    },
    {
      "Impact": "Enable",
      "Motion": [
        "ec2:DescribeInstances",
        "ec2:DescribeImages"
      ],
      "Useful resource": "*",
      "Situation": {
        "StringEquals": {
          "ec2:Area": "us-east-1"
        }
      }
    }
  ]
}

Create Amazon Bedrock AgentCore Runtime agent

From Amazon AgentCore, select runtime from the menu, then select host/agent instrument. Present a novel title in your runtime agent. For Agent Supply, choose the ECR container possibility and enter the picture URI from AWS Market.

On the identical web page, below permissions, choose the present position created within the earlier step.

Within the inbound auth part on the identical web page, choose the MCP protocol and JWT token for inbound auth kind. For JWT schema configuration, use the present identification supplier configuration (the Cognito identification pool created in step one).

Get hold of the invention URL out of your Cognito consumer pool data. Search for the Token signing key URL, which follows this format:https://cognito-idp.$REGION.amazonaws.com/$POOL_ID/.well-known/jwks.json

Change jwks.json with openid-configuration. Your last URL ought to look just like this instance:

https://cognito-idp.us-east-1.amazonaws.com/us-east-1_ev5CwXjma/.well-known/openid-configuration

Add allowed shoppers to your configuration. Navigate to the App Consumer part in your Cognito consumer pool by selecting App Consumer within the left panel. Copy the consumer ID from the App consumer data and add it to the allowed shoppers part.

Configure superior settings in your AgentCore Runtime deployment. Beneath Superior configurations, hold the default community mode set to Public for this walkthrough. This enables the runtime to be reachable over the web throughout preliminary setup and testing.

For manufacturing deployments, select the VPC possibility to limit community entry to personal, managed environments. That is the really helpful strategy for workloads dealing with delicate information or requiring community isolation. Subsequent, add your atmosphere variables as proven within the following part, then select Create agent.

• AUTH_TYPE: “no-auth”
• AWS_API_MCP_HOST: “0.0.0.0”
• AWS_API_MCP_PORT: “8000”
• AWS_API_MCP_STATELESS_HTTP: “true”
• AWS_API_MCP_TRANSPORT: “streamable-http”
• AWS_API_MCP_ALLOWED_HOSTS = “*”
• AWS_API_MCP_ALLOWED_ORIGINS = “*”

Understanding AWS API authentication on AgentCore

The AUTH_TYPE is about to no-auth as a result of the MCP server itself doesn’t carry out authentication. That is intentional and protected when deploying via Amazon Bedrock AgentCore Runtime. AgentCore Runtime acts because the safety boundary. Earlier than a request reaches your MCP server container, AgentCore Runtime enforces JWT token validation. It verifies cryptographic signatures utilizing public keys from AgentCore Identification, validates token claims (issuer, viewers, expiration), and rejects requests that don’t current a legitimate OAuth 2.0 bearer token. In different phrases: the MCP server trusts that AgentCore Runtime has already authenticated the caller. This is similar sample utilized by inner microservices behind an API Gateway. The service itself doesn’t re-authenticate as a result of the gateway already did.

Observe: Don’t use AUTH_TYPE: no-auth if you happen to’re working this MCP server outdoors of AgentCore Runtime (for instance, instantly on an EC2 occasion or as a standalone container). In that state of affairs, the server can be uncovered with out an authentication layer.

The wildcard values for AWS_API_MCP_ALLOWED_HOSTS and AWS_API_MCP_ALLOWED_ORIGINS (*) are deliberately broad for this tutorial. In manufacturing, exchange these with the precise hostnames and origins your workload requires to implement least-privilege community entry.

Create customized chat agent in Amazon Fast

Now that you’ve the AWS API MCP server working in Amazon Bedrock AgentCore Runtime, let’s create a customized chat agent in Amazon Fast that can be utilized to execute AWS CLI instructions via pure language interactions.

Navigate to the Amazon Fast console, entry integration settings. Within the left navigation panel, select Integrations, then choose Actions. Add the MCP protocol integration to attach Amazon Fast together with your MCP server hosted on Amazon Bedrock AgentCore Runtime.

To configure the combination particulars, enter integration metadata. Present a descriptive Identify in your integration after which add a transparent Description explaining the combination’s goal.

For endpoint configuration, retrieve your Amazon Bedrock AgentCore Runtime ARN. Navigate to your agent’s Instruments Particulars part. Copy the Runtime ARN from the Runtime part.

Instance ARN format:

arn:aws:bedrock-agentcore:us-east-1:123456789123:runtime/demoagent-LmNop08QoR

The tip level URL needs to be within the following format, exchange Area together with your AWS Area and comply with steps to create url encoded arn.

https://bedrock-agentcore.{area}.amazonaws.com/runtimes/{url-encoded-arn}/invocations?qualifier=DEFAULT

To create a URL-encoded ARN, run the next command in your terminal:

echo "YOUR_ARN" | sed 's/:/%3A/g; s///%2F/g'

[System.Uri]::EscapeDataString("YOUR_ARN")

Observe: The bash command requires Linux, macOS, or Home windows with WSL (Home windows Subsystem for Linux) put in. The Home windows PowerShell cmdlet works natively on Home windows methods with out further dependencies.Lastly hold the allow auto-publishing possibility enabled.To determine safe communication between Amazon Fast and the MCP server, configure service authentication utilizing your Amazon Cognito consumer pool credentials.

Observe: Amazon Cognito is a totally managed AWS identification service that handles authentication and authorization in your purposes. App consumer secrets and techniques are saved encrypted at relaxation and in transit. Your credentials aren’t transmitted in plaintext. Cognito additionally helps on-demand consumer secret rotation, so you’ll be able to preserve as much as two energetic secrets and techniques per app consumer for zero-downtime rotation.

When prompted within the authentication settings web page, choose Service Authentication as your authentication technique.

To search out your Consumer ID and Consumer Secret:

1. Open the Amazon Cognito console.
2. Select Consumer Swimming pools, then choose your consumer pool.
3. Within the left navigation pane, select App shoppers (below Purposes).
4. Choose your app consumer. The App consumer ID is displayed instantly on this web page.
5. Select Present consumer secret to disclose the App consumer secret.

Observe: Deal with your Consumer Secret like a password. Retailer it securely utilizing AWS Secrets and techniques Supervisor for manufacturing deployments. Don’t embed it in client-side code or model management.

For the Token URL, assemble it utilizing your consumer pool’s area:

1. Within the left navigation pane of your consumer pool, scroll right down to Branding part.
2. Select Area. Your Cognito area is displayed right here within the format: https://your-domain.auth.area.amazoncognito.com
3. Append /oauth2/token to this area to type your full token endpoint: https://your-domain.auth.area.amazoncognito.com/oauth2/token

After you’ve entered the Consumer ID, Consumer Secret, and Token URL, select Create and Proceed.

Observe: Inside Amazon Fast, your credentials are encrypted utilizing AWS Key Administration Service (AWS KMS). By default, Fast makes use of a service-managed AWS KMS key to encrypt information supply credentials and OAuth tokens. For organizations with stricter compliance necessities, account directors can configure buyer managed keys to take care of full management over encryption key lifecycle, together with the power to revoke entry immediately and preserve an auditable log of credential entry.

Subsequent, set the sharing preferences for this motion. Select whether or not to share this motion with different group members and configure applicable entry permissions. Select Carried out and confirm that the motion seems within the Actions part.

Now let’s construct a conversational agent that interprets pure language into AWS CLI instructions. Navigate to agent creation in Amazon Fast console, within the left panel, select Customized Brokers, then select Create Chat Agent.

Configure the agent with a descriptive immediate:

Immediate: Create a conversational agent that enables customers to execute AWS CLI instructions utilizing pure language. Interprets consumer requests into applicable AWS API calls via the aws-api-mcp connector.

Amazon Fast mechanically detects and selects the MCP connector based mostly in your immediate. Confirm that the proper integration is related together with your agent. Select Launch Agent to make it accessible for testing.

Automated deployment

For automated deployment, comply with the directions in GitHub to deploy the AWS API MCP server in Amazon Bedrock Runtime.Moreover, to deploy Cognito consumer pool and app consumer, comply with the AWS documentation directions below the Appendix part in Arrange Cognito consumer pool for authentication.

Lastly, for establishing the combination between Amazon Fast and AWS API MCP server, comply with the steps talked about within the part Create Customized Chat Agent in Amazon Fast.

Check the answer

To validate your customized chat agent performance, entry the chat interface in your newly created customized chat agent and take a look at pure language instructions:

Immediate: Present working EC2 situations within the us-east-1 area.

Clear up

To keep away from incurring ongoing fees, clear up the assets that you simply created as a part of this resolution.

1. Delete the Amazon Fast assets. Take away the Amazon Fast options that you simply enabled, together with your customized chat agent, Areas, and Flows.
2. Take away the MCP integration. Delete the Amazon Fast MCP motion that you simply created.
3. Clear up Amazon Bedrock assets. Delete the Amazon Bedrock AgentCore agent and its related IAM execution position.
4. Delete the Amazon Cognito consumer pool. Lastly, take away the Amazon Cognito consumer pool that you simply created for authentication.

Conclusion

On this submit, you discovered easy methods to join Amazon Fast with AWS companies utilizing Amazon Bedrock AgentCore Runtime and the AWS API MCP Server. If you standardize how AI brokers work together together with your infrastructure via MCP, you’ll be able to keep away from the necessity to rebuild customized integration patterns for every new use case.

From right here, you’ll be able to prolong this sample to automate widespread operational queries. You may also construct domain-specific brokers for safety, price optimization, or capability planning, and combine with incident administration workflows utilizing Amazon Fast Flows and Amazon Fast Automate. The result’s a extra constant, safe, and environment friendly strategy to handle AWS infrastructure at scale.

In regards to the authors