CloudCraft Agent

Elevator pitch An autonomous DevOps assistant that builds and deploys serverless applications on AWS from simple, conversational prompts.

Comment

Inspiration

Modern cloud platforms like AWS offer incredible power, but their complexity often leads to significant challenges. As systems grow, human error becomes a major source of risk, inefficiency, and cost in deployment processes. Industry data suggests human error is linked to 74-95% of cybersecurity breaches and potentially up to 99% of cloud failures. Misconfigurations, often stemming from cognitive overload or misunderstandings like the shared responsibility model, can have severe financial impacts, with downtime costing thousands per minute. This inspired the creation of CloudCraft Agent, an AI DevOps assistant built for the AWS AI Agent Global Hackathon. The vision was to leverage Amazon Bedrock Agents to bridge the gap between human intent ("Deploy a website") and the complex sequence of actions needed, thereby reducing the potential for costly manual errors.

How I Built It

CloudCraft Agent uses a serverless, agentic architecture centered around AWS services:

  1. The Brain (AI Core): Agents for Amazon Bedrock orchestrates the workflow, using Anthropic's Claude 3 Sonnet model for reasoning and planning based on natural language prompts.

  2. The Tools (Action Group): An AWS Lambda function, written in Python, serves as the action group. It contains the boto3 code to execute specific AWS tasks like creating S3 buckets (create_s3_bucket), managing public access (disable_s3_block_public_access, set_public_read_policy), configuring hosting (configure_s3_static_hosting), and creating basic Lambda functions (create_hello_world_lambda).

  3. Automated Setup (setup.py): A Python script automates the initial creation of the necessary IAM Roles (for the agent and Lambda), the Lambda function itself, and the Bedrock Agent, significantly speeding up deployment and ensuring consistency. The agent's tools are defined directly within this script using the functionSchema for improved reliability over external OpenAPI files.

  4. The Interface (Frontend/Backend): A simple HTML/CSS/JavaScript frontend provides a chat interface. It communicates with a lightweight Flask backend server running locally. The Flask app securely invokes the Bedrock Agent using boto3 and streams the response back to the user. It also includes an endpoint to handle file uploads directly to S3 via boto3 after the agent creates the bucket.

Challenges Faced

  • Building this agent involved overcoming several hurdles inherent to cloud automation and AI integration:

  • IAM Permissions: Debugging the intricate chain of permissions was the most significant challenge. This included ensuring the local user could invoke the agent, the agent's role could invoke the Lambda function, the Lambda's role could manage AWS resources (S3, Lambda), and finally, that the agent's role could invoke the underlying foundation model. This required careful configuration of IAM policies and Lambda resource-based policies.

  • Agent Tool Definition: Initially, I attempted using OpenAPI schemas, but persistent ValidationException errors, likely due to subtle formatting issues, proved difficult to resolve. Switching to defining the functions directly within the setup.py script (functionSchema) provided a much more robust and reliable method.

  • Agent Reasoning: Guiding the agent to correctly use its tools required very explicit instructions, especially for the create_hello_world_lambda tool, to prevent it from incorrectly asking for user-provided code files when the tool was designed to be self-contained.

  • Local Credential Conflicts: An elusive AccessDeniedException was eventually traced back to conflicting AWS credentials on the local machine, requiring a "hard reset" using named profiles (aws configure --profile) and explicit session creation in boto3 to resolve.

What I Learned

*This project was a deep dive into building practical AI agents on AWS:

  • IAM is Foundational: Mastering IAM policies, roles, trust relationships, and resource-based policies is absolutely critical for any AWS automation.

  • Bedrock Agents are Powerful: They provide a robust framework for creating goal-oriented AI, abstracting much of the complexity of the reasoning loop.

  • Explicit Instructions Matter: LLMs require very clear, unambiguous instructions and tool descriptions to perform reliably, especially when dealing with complex sequences or tool limitations.

  • Infrastructure as Code Simplifies: Automating the setup with setup.py made the process repeatable and less error-prone than manual console configuration

Built With

Share this project:

Updates