aws-skillv1.0.0latest

---
name: aws-skill
version: 1.0.0
url: https://clawskills.io/api/skills/aws-skill/releases/1.0.0/SKILL.md
artifact_sha256: ebf5f4fe05647ad6f80c7f06967f5eda4ea4c3d8d3a63c9c44eb88e8c38c4dda
signature: VbZr4AQ1KkRLFBW3LY/a5jWiXinF8N4diKT5+mxuqGEjRdeapoKofrzWR+7Tn2tcq+9QkD8TTyX329APNodVDg==
key_id: 625b196966442b38cf1c7188ba15fa81
verify: https://clawskills.io/docs/verification
---
# AWS Skill

Manage AWS cloud resources — S3 buckets, Lambda functions, EC2 instances, DynamoDB tables, and 15,000+ AWS APIs — using the official AWS MCP Server.

---

## Overview
- **What it does:**
  Lets an AI agent interact with AWS services — create and manage S3 buckets, deploy Lambda functions, provision EC2 instances, query DynamoDB tables, search AWS documentation, and call most AWS APIs via natural language — using the official managed AWS MCP Server.

- **When to use it:**
  When the user wants to manage AWS infrastructure from an AI agent: deploying resources, troubleshooting Lambda errors, querying DynamoDB, managing S3 objects, looking up AWS documentation, or automating cloud operations.

- **Requirements:**
  - OS: macOS / Linux / Windows
  - Runtime: Python 3.10+ (for `uvx`)
  - Accounts: AWS account with IAM credentials (named profile, SSO, or access key + secret key)

---

## Quick start

### Install

Add to your OpenClaw config (`~/.openclaw/openclaw.json`):

```json
{
  "mcpServers": {
    "aws-mcp": {
      "command": "uvx",
      "args": [
        "mcp-proxy-for-aws@1.1.6",
        "https://aws-mcp.us-east-1.api.aws/mcp",
        "--metadata", "AWS_REGION=us-east-1"
      ]
    }
  }
}
```

Replace `us-east-1` with your preferred region. The `mcp-proxy-for-aws` package handles SigV4 authentication locally — credentials never leave your machine.

To use a named AWS profile, add an `env` block:

```json
{
  "mcpServers": {
    "aws-mcp": {
      "command": "uvx",
      "args": [
        "mcp-proxy-for-aws@1.1.6",
        "https://aws-mcp.us-east-1.api.aws/mcp",
        "--metadata", "AWS_REGION=us-east-1"
      ],
      "env": {
        "AWS_PROFILE": "default"
      }
    }
  }
}
```

### Configure

Set up AWS credentials using one of these methods:

```bash
# Option 1 (recommended): Named profile via AWS CLI
#   Run: aws configure --profile default
#   This stores credentials in AWS CLI shared credentials files (not in your shell history).
#
# Option 2: SSO
#   Run: aws sso login --profile default
#   Refreshes temporary credentials from your identity provider.
#
# Option 3: Access keys — set in OpenClaw runtime environment
#   (Control UI env editor if available, process env, or .env):
#   AWS_ACCESS_KEY_ID      — your IAM access key ID
#   AWS_SECRET_ACCESS_KEY  — your IAM secret access key
#   AWS_SESSION_TOKEN      — (optional) for temporary credentials from STS
#
# If your region isn't set in your AWS profile, also add:
#   AWS_REGION             — e.g., us-east-1
#
# Get credentials from: https://console.aws.amazon.com/iam/
```

**IAM policy** — if not using an administrator role, attach this policy to your IAM user/role:

```json
{
  "Version": "2012-10-17",
  "Statement": [
    {
      "Effect": "Allow",
      "Action": [
        "aws-mcp:InvokeMcp",
        "aws-mcp:CallReadOnlyTool",
        "aws-mcp:CallReadWriteTool"
      ],
      "Resource": "*"
    }
  ]
}
```

For read-only access, omit `aws-mcp:CallReadWriteTool`.

### Verify

After connecting, ask your AI agent:

```text
List my S3 buckets
```

**Expected result:**
Returns a list of S3 bucket names and creation dates from your AWS account.

You can also verify credentials directly:

```bash
aws sts get-caller-identity
```

This confirms which IAM identity is active and shows the account ID, user ARN, and user ID.

---

## Core tasks

### List and manage S3 buckets

```text
List my S3 buckets, then show the contents of the "my-app-assets" bucket
```

### Deploy a Lambda function

```text
Create a Lambda function called "my-handler" with Python 3.12 runtime in us-east-1, using the code in handler.zip from S3 bucket "my-deploys"
```

### Manage EC2 instances

```text
List my running EC2 instances in us-east-1 with their instance IDs, types, and public IPs
```

### Query DynamoDB

```text
Scan the DynamoDB table "users" for items where status = "active", limit 10
```

### Search AWS documentation

```text
How do I set up an S3 bucket policy to allow public read access to objects?
```

### Get planning guidance

```text
I need to build a serverless REST API with authentication. What AWS services should I use?
```

The AWS MCP Server includes Agent SOPs — pre-built, step-by-step workflows for common AWS tasks that follow AWS best practices.

### Manage CloudWatch alarms

```text
List CloudWatch alarms in alarm state for the us-east-1 region
```

---

## Server capabilities

The AWS MCP Server is a managed remote service that combines three capabilities in one server:

| Capability | Description |
|---|---|
| **API Tools** | Authenticated execution of 15,000+ AWS APIs via SigV4 — generates and executes syntactically correct CLI commands from natural language |
| **Knowledge Tools** | Real-time access to AWS documentation, API references, best practices, and regional availability |
| **Agent SOPs** | Pre-built, step-by-step workflows for complex AWS tasks that follow AWS best practices |

All API calls are logged through **AWS CloudTrail** for audit visibility. There are no additional charges for the MCP server itself — you pay only for the AWS resources used.

**Key tools:**
- `aws__search_documentation` — search AWS documentation and best practices
- `retrieve_agent_sop` — retrieve step-by-step workflows for AWS tasks
- AWS API execution — call any AWS service API via natural language

**Supported services include:** S3, EC2, Lambda, DynamoDB, CloudWatch, IAM, SQS, SNS, CloudFormation, RDS, ECS, EKS, API Gateway, Route 53, Secrets Manager, SSM, Step Functions, and most other AWS services.

---

## Environment variable contract

| Variable | Purpose | Required | Where to set |
|---|---|---|---|
| `AWS_PROFILE` | Named profile for credential resolution | Choose one auth method | `env` block in `openclaw.json` |
| `AWS_ACCESS_KEY_ID` | IAM access key ID | Choose one auth method | OpenClaw runtime environment |
| `AWS_SECRET_ACCESS_KEY` | IAM secret access key | Choose one auth method | OpenClaw runtime environment |
| `AWS_SESSION_TOKEN` | Temporary session token (STS) | Optional | OpenClaw runtime environment |
| `AWS_REGION` | AWS region (e.g., `us-east-1`) | Recommended | `--metadata` arg in `openclaw.json` |

Credentials are inherited by the MCP proxy process from the OpenClaw runtime environment.

---

## Configuration

* **Secrets / credentials required:**

  * `AWS_ACCESS_KEY_ID` — IAM access key ID (if using access keys)
  * `AWS_SECRET_ACCESS_KEY` — IAM secret access key (if using access keys)
  * `AWS_SESSION_TOKEN` — temporary session token (optional, for STS/assumed roles)

* **Non-secret config:**

  * `AWS_PROFILE` — name of your AWS CLI named profile (recommended auth method)
  * `AWS_REGION` — AWS region (e.g., `us-east-1`)

* **How to obtain credentials:**

  1. Go to https://console.aws.amazon.com/iam/
  2. Create an IAM user or role with the permissions you need
  3. Generate access keys under Security credentials
  4. Or use `aws configure` to set up a named profile via the AWS CLI
  5. Or use `aws sso login` if your organization uses AWS IAM Identity Center

* **Config files used:**

  * AWS CLI shared credentials file — AWS credentials managed by `aws configure`
  * AWS CLI shared config file — AWS profiles and region settings
  * `~/.openclaw/openclaw.json` — MCP server configuration

* **How to reset / re-auth:**

  * Deactivate the IAM access key in the AWS Console
  * Generate a new access key and run `aws configure` again
  * Update environment variables with the new credentials
  * For SSO: run `aws sso login --profile <profile-name>` to refresh

---

## Security & Guardrails

### Secrets handling

* Never paste AWS access keys or secret keys into chat.
* Never pass credentials as command-line arguments (visible in `ps` output).
* Always use environment variables, AWS named profiles, or SSO.
* Prefer IAM roles and temporary credentials (STS AssumeRole) over long-lived access keys.
* If authentication fails, recommend rotating the access key immediately.
* SigV4 authentication is handled locally by the proxy — credentials never leave your machine.

### Confirmations (before risky actions)

* Always confirm with the user before:
  * Creating or deleting resources (S3 buckets, EC2 instances, Lambda functions, DynamoDB tables)
  * Modifying security groups or IAM policies (affects access control)
  * Stopping or terminating EC2 instances (may cause downtime)
  * Deleting S3 objects or buckets (data loss is irreversible unless versioning is enabled)
  * Any action that incurs AWS costs (provisioning resources)
* The agent should present the planned API call and parameters before executing destructive or costly operations.

### Cost guardrails

* Default to `DryRun=true` when AWS APIs support it (e.g., EC2 RunInstances, CreateSecurityGroup). Only proceed with the real call after the user approves.
* Before creating any resource, estimate the cost and show the service, region, and resource class (e.g., "t3.micro in us-east-1 ≈ $0.0104/hr").
* Flag any action that provisions resources with ongoing costs (EC2, RDS, NAT Gateways, etc.).

### Data minimization

* Return resource summaries by default — don't dump full API responses.
* Limit list operations with reasonable page sizes.
* Avoid echoing credentials or account IDs in output.
* Never log or display `AWS_SECRET_ACCESS_KEY` values.

### Permissions / scopes

* **IAM policy:** Use `aws-mcp:CallReadOnlyTool` only for read-only access. Add `aws-mcp:CallReadWriteTool` only when write access is needed.
* **Recommended default: start with read-only access.** Attach `ReadOnlyAccess` managed policy or service-specific read-only policies:
  * S3 read-only: `AmazonS3ReadOnlyAccess`
  * Lambda read-only: `AWSLambda_ReadOnlyAccess`
  * EC2 read-only: `AmazonEC2ReadOnlyAccess`
  * DynamoDB read-only: `AmazonDynamoDBReadOnlyAccess`
* Upgrade to write permissions only when the user needs to create or modify resources.

### Network access

* **Domains used:**
  * `aws-mcp.us-east-1.api.aws` — AWS MCP Server endpoint
  * `*.amazonaws.com` — AWS API endpoints (called server-side by the MCP Server)
  * `console.aws.amazon.com` — AWS Console (for obtaining credentials)

### Local storage

* **Reads from:** AWS CLI shared credentials/config files (managed by `aws configure`)
* **Writes to:** Nothing beyond the standard AWS CLI config
* **Audit:** All API calls are logged in AWS CloudTrail
* **Does not access:** SSH private key directories (unless explicitly instructed), browser profiles, keychains

### Revoke / rotate

* Deactivate access keys: IAM Console > Users > select user > Security credentials > Deactivate
* Delete access keys: IAM Console > Users > select user > Security credentials > Delete
* Rotate: Create a new access key, update credentials (`aws configure`), verify with `aws sts get-caller-identity`, then delete the old key
* For SSO: Revoke the SSO session in your identity provider

---

## Troubleshooting

* **Error:** `ExpiredTokenException` or `InvalidClientTokenId`
  * Fix: Your credentials have expired. If using temporary credentials, refresh them with `aws sts assume-role` or `aws sso login`. If using long-lived keys, check that they haven't been deactivated.

* **Error:** `AccessDeniedException` or `UnauthorizedAccess`
  * Fix: Your IAM user/role lacks the required permissions. Ensure the `aws-mcp:InvokeMcp` and `aws-mcp:CallReadOnlyTool` actions are allowed in your IAM policy. Use the IAM Policy Simulator to test: https://policysim.aws.amazon.com

* **Error:** `Region not found` or `Could not connect to endpoint`
  * Fix: Verify `AWS_REGION` is set to a valid region. Check the `--metadata AWS_REGION=` argument in your `openclaw.json`. Check your network connection.

* **Problem:** "uvx command not found"
  * Fix: Install `uv` by following the instructions at https://docs.astral.sh/uv/getting-started/installation/. Then `uvx` will be available.

* **Problem:** "MCP server fails to start"
  * Fix: Ensure Python 3.10+ is installed. Run `uvx mcp-proxy-for-aws@1.1.6 https://aws-mcp.us-east-1.api.aws/mcp` manually to check for errors. Verify that AWS credentials are configured (`aws sts get-caller-identity`).

* **Problem:** SSO credentials not working
  * Fix: Run `aws sso login --profile default` to refresh your SSO session. If the session has expired, you'll be prompted to re-authenticate in the browser. Verify with `aws sts get-caller-identity --profile default`.

---

## Release notes

* v1.1.0:
  * Switch to managed AWS MCP Server (`mcp-proxy-for-aws@1.1.6`)
  * Single server replaces three separate open-source servers
  * Add IAM policy for managed server, CloudTrail audit note
  * Add Agent SOPs documentation

* v1.0.0:
  * Initial release using open-source AWS Labs MCP servers

---

## Links

* AWS MCP Server docs: https://docs.aws.amazon.com/aws-mcp/latest/userguide/what-is-mcp-server.html
* AWS MCP Server setup: https://docs.aws.amazon.com/aws-mcp/latest/userguide/getting-started-aws-mcp-server.html
* MCP Proxy for AWS (PyPI): https://pypi.org/project/mcp-proxy-for-aws/
* MCP Proxy for AWS (GitHub): https://github.com/aws/mcp-proxy-for-aws
* AWS IAM Console: https://console.aws.amazon.com/iam/
* AWS CLI installation: https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html

---

## Publisher

* **Publisher:** @Agentopolis