AWS Orchestrator Examples

Common use cases and example workflows for the AWS Orchestrator Agent.

Single Service Per Request

The AWS Orchestrator Agent generates one service module at a time. If your request mentions multiple AWS services, the agent will automatically pick the first service mentioned and generate a complete module for it.

Example: If you request "Create modules for S3, RDS, and Lambda", the agent will generate only the S3 module.

For multiple services, submit separate requests for each service.

---

Quick Start Example

Step 1: Start the Server

Option A: Docker (Recommended)

docker run -d -p 10102:10102 \
  -e OPENAI_API_KEY=your_key \
  --name aws-orchestrator \
  sandeep2014/aws-orchestrator-agent:latest

# Verify the server is running
docker logs aws-orchestrator

Option B: Standalone

# From the cloned repository
aws-orchestrator-agent \
  --host 0.0.0.0 \
  --port 10102 \
  --agent-card aws_orchestrator_agent/card/aws_orchestrator_agent.json

Step 2: Set Up the Client

Client Required

Regardless of how you installed the agent (Docker or Standalone), you need the Python client to interact with the server.

# Clone the repository to get the client
git clone https://github.com/talkops-ai/aws-orchestrator-agent.git
cd aws-orchestrator-agent

# Install client dependencies (if you get import errors)
pip install httpx colorama

Step 3: Connect to the Server

python aws_orchestrator_client/client.py

Client Options:

Option	Default	Description
--agent	http://localhost:10102	Server URL to connect to
--session	0	Session ID to use
--history	False	Show session history

Example with options:

python aws_orchestrator_client/client.py \
  --agent http://localhost:10102 \
  --session 1 \
  --history True

---

Enterprise S3 Module

Request

"Help me create an enterprise S3 module with versioning, 
encryption, and lifecycle policies"

Generated Files

modules/s3-enterprise/
├── main.tf           # S3 bucket with encryption, versioning
├── variables.tf      # Input variables with validation
├── outputs.tf        # Bucket ARN, ID, endpoint outputs
├── locals.tf         # Local values for naming
├── backend.tf        # Remote state configuration
└── README.md         # Usage documentation

Sample Output: main.tf

resource "aws_s3_bucket" "main" {
  bucket = var.bucket_name
  tags   = local.common_tags
}

resource "aws_s3_bucket_versioning" "main" {
  bucket = aws_s3_bucket.main.id
  versioning_configuration {
    status = "Enabled"
  }
}

resource "aws_s3_bucket_server_side_encryption_configuration" "main" {
  bucket = aws_s3_bucket.main.id
  rule {
    apply_server_side_encryption_by_default {
      sse_algorithm     = "aws:kms"
      kms_master_key_id = var.kms_key_id
    }
  }
}

---

VPC with Subnets

Request

"Create a VPC module with public and private subnets across 
multiple availability zones"

Generated Structure

modules/vpc-multi-az/
├── main.tf           # VPC, subnets, IGW, NAT
├── variables.tf      # CIDR, AZ, naming variables
├── outputs.tf        # VPC ID, subnet IDs
├── data.tf           # AZ data source
├── locals.tf         # Subnet CIDR calculations
└── README.md

Sample Output: main.tf

resource "aws_vpc" "main" {
  cidr_block           = var.vpc_cidr
  enable_dns_hostnames = true
  enable_dns_support   = true
  tags                 = local.common_tags
}

resource "aws_subnet" "public" {
  count                   = length(var.availability_zones)
  vpc_id                  = aws_vpc.main.id
  cidr_block              = local.public_subnet_cidrs[count.index]
  availability_zone       = var.availability_zones[count.index]
  map_public_ip_on_launch = true
  tags = merge(local.common_tags, {
    Type = "public"
  })
}

resource "aws_subnet" "private" {
  count             = length(var.availability_zones)
  vpc_id            = aws_vpc.main.id
  cidr_block        = local.private_subnet_cidrs[count.index]
  availability_zone = var.availability_zones[count.index]
  tags = merge(local.common_tags, {
    Type = "private"
  })
}

---

RDS PostgreSQL

Request

"Create an RDS PostgreSQL module with Multi-AZ and 
automated backups"

Generated Structure

modules/rds-postgresql/
├── main.tf           # DB instance, subnet group, params
├── variables.tf      # Instance class, storage, credentials
├── outputs.tf        # Endpoint, ARN, connection info
├── locals.tf         # Naming, tags
└── README.md

---

EKS Cluster

Request

"Create an EKS cluster module with managed node groups"

Generated Structure

modules/eks-cluster/
├── main.tf           # EKS cluster, node groups
├── variables.tf      # Cluster config, node config
├── outputs.tf        # Cluster endpoint, kubeconfig
├── data.tf           # VPC, IAM data sources
├── locals.tf         # Node group configurations
└── README.md

---

Workflow Timeline

Phase	Duration	Description
Planner	5-7 min	Requirements analysis, execution planning
Generator	10-12 min	Resource, variable, output generation
Writer	3-5 min	File validation and writing
Total	20-25 min	Complete enterprise-grade module

---

Example Session

$ python aws_orchestrator_client/client.py

AWS Orchestrator Agent v0.1.0
Connected to: http://localhost:10102

> Create an S3 bucket module with versioning and encryption

🔄 Starting workflow...

📋 Planner Phase
   ├── Analyzing requirements...
   ├── Creating execution plan...
   └── Evaluating security best practices...

🏭 Generator Phase
   ├── Generating resource configuration...
   ├── Creating variable definitions...
   ├── Generating outputs...
   └── Creating documentation...

📝 Writer Phase
   ├── Validating HCL syntax...
   ├── Creating directory structure...
   └── Writing files...

✅ Complete!

Generated module: modules/s3-bucket/
├── main.tf
├── variables.tf
├── outputs.tf
├── locals.tf
├── backend.tf
└── README.md

Total time: 22 minutes