Amazon Bedrock AgentCore Deployment

Overview

Deploy AI agents to Amazon Bedrock AgentCore using multiple approaches: starter toolkit for rapid deployment, direct code deployment for customization, and container deployment for complex dependencies. Includes CI/CD patterns and infrastructure as code.

Purpose: Deploy agents from development to production with best practices

Pattern: Workflow-based (4 deployment methods)

Key Principles (validated by AWS December 2025):

1. Zero Infrastructure - Managed compute, no servers to manage
2. arm64 Architecture - All deployments use arm64
3. Session Isolation - Complete isolation between sessions
4. Multiple Entry Points - SDK decorator or REST endpoints
5. Observability Built-in - CloudWatch and OTel integration
6. Framework Agnostic - Works with any Python agent framework

Quality Targets:

• Deployment time: < 5 minutes
• Cold start: < 2 seconds
• Package size: 250MB (zip), 750MB (unzipped)

---

When to Use

Use bedrock-agentcore-deployment when:

• Deploying agent code to production
• Setting up CI/CD pipelines for agents
• Migrating from development to production
• Managing multiple agent versions
• Implementing blue-green deployments

When NOT to Use:

• Local development/testing (use local server)
• Standard Bedrock Agents with action groups

---

Prerequisites

Required

• AWS account with AgentCore access
• Python 3.10+ (recommended: 3.13)
• IAM role with AgentCore permissions
• Foundation model access enabled

Recommended

• AWS CLI configured
• Docker (for container deployments)
• GitHub Actions or GitLab CI (for CI/CD)

---

Deployment Method 1: Starter Toolkit (Fastest)

Time: 2-5 minutes Complexity: Low Best For: Rapid deployment, simple agents

Step 1: Install Toolkit

pip install bedrock-agentcore strands-agents bedrock-agentcore-starter-toolkit

# Verify
agentcore --help

Step 2: Create Agent

# main.py
from bedrock_agentcore import BedrockAgentCoreApp
from strands import Agent

app = BedrockAgentCoreApp()
agent = Agent(model="anthropic.claude-sonnet-4-20250514-v1:0")

@app.entrypoint
def invoke(payload):
    prompt = payload.get("prompt", "Hello!")
    result = agent(prompt)
    return {"response": result.message}

if __name__ == "__main__":
    app.run()

Step 3: Configure

# Initialize configuration
agentcore configure -e main.py -n my-production-agent

# This creates .bedrock_agentcore.yaml

Step 4: Test Locally

# Start local server
python main.py &

# Test
curl -X POST http://localhost:8080/invocations \
  -H "Content-Type: application/json" \
  -d '{"prompt": "Hello, world!"}'

# Stop local server
pkill -f main.py

Step 5: Deploy

# Deploy to AWS
agentcore deploy

# Output: Agent ARN
# arn:aws:bedrock-agentcore:us-east-1:123456789012:agent-runtime/my-production-agent

Step 6: Test Deployed

# Test via CLI
agentcore invoke '{"prompt": "Hello from production!"}'

# Test via boto3
python -c "
import boto3
client = boto3.client('bedrock-agentcore')
response = client.invoke_agent_runtime(
    agentRuntimeArn='arn:...',
    runtimeSessionId='test-1',
    payload={'prompt': 'Hello!'}
)
print(response['payload'])
"

---

Deployment Method 2: Direct Code Deploy

Time: 10-15 minutes Complexity: Medium Best For: Custom dependencies, specific configurations

Step 1: Project Structure

my-agent/
├── main.py              # Entry point
├── agent/
│   ├── __init__.py
│   └── logic.py         # Agent logic
├── pyproject.toml       # Dependencies
└── requirements.txt     # Alternative deps format

Step 2: Create Entry Point

# main.py - REST endpoint pattern
from flask import Flask, request, jsonify

app = Flask(__name__)

@app.route('/invocations', methods=['POST'])
def invoke():
    payload = request.get_json()
    prompt = payload.get('prompt', '')

    # Your agent logic here
    from agent.logic import process_request
    result = process_request(prompt)

    return jsonify({'response': result})

@app.route('/ping', methods=['GET'])
def ping():
    return 'OK', 200

if __name__ == '__main__':
    app.run(host='0.0.0.0', port=8080)

Step 3: Package for arm64

# Create virtual environment
uv init agent-deploy --python 3.13
cd agent-deploy

# Install dependencies for arm64
uv pip install \
    --python-platform aarch64-manylinux2014 \
    --python-version 3.13 \
    --target=deployment_package \
    --only-binary=:all: \
    -r requirements.txt

# Create ZIP
cd deployment_package
zip -r ../deployment_package.zip .
cd ..

# Add main.py
zip deployment_package.zip main.py

# Add agent module
zip -r deployment_package.zip agent/

Step 4: Upload to S3

aws s3 cp deployment_package.zip s3://my-bucket/agents/v1.0.0/package.zip

Step 5: Create Agent Runtime

import boto3

control = boto3.client('bedrock-agentcore-con

...