AWS Builder Center

Builder Center

AWS Cloud Buddy: Building an AI-Powered AWS Troubleshooting Assistant

Discover **AWS Cloud Buddy**, an AI-powered AWS troubleshooting assistant built with Python, Flask, Groq, and Amazon EC2. Get step-by-step guidance for AWS Lambda errors, IAM permission issues, Amazon ECS failures, and DynamoDB problems, with helpful links to official AWS documentation. Explore how generative AI can simplify cloud debugging and accelerate AWS learning. #AWS #AI #CloudComputing #GenerativeAI #agents

Introduction

When working with AWS, troubleshooting errors can be challenging, especially when you're still learning cloud services. An issue involving AWS Lambda, API Gateway, IAM permissions, Amazon ECS, or Amazon DynamoDB can require checking multiple configurations, reading documentation, and understanding the underlying cause before finding a solution.
As part of my cloud learning journey, I built AWS Cloud Buddy, an AI-powered cloud troubleshooting assistant designed to help developers understand AWS errors and explore possible solutions through a simple chat interface.
The goal was to build more than a basic chatbot. I wanted to create a practical tool that accepts AWS-related questions, generates structured troubleshooting guidance, and provides links to official AWS documentation for further investigation.

What Is AWS Cloud Buddy?

AWS Cloud Buddy is a web-based AI assistant that helps users troubleshoot common AWS issues through natural-language questions.
For example, a user can ask:
  • How do I troubleshoot a Lambda 502 error?
  • Why am I getting an AccessDeniedException when accessing Amazon S3?
  • Why does my Amazon ECS Fargate task keep stopping?
  • How do I fix a DynamoDB reserved-keyword error?
Instead of manually searching through multiple resources before getting started, users can ask a question and receive an organized explanation containing possible causes, debugging steps, code examples where appropriate, and relevant documentation links.
The assistant is intended to support troubleshooting and learning. Its suggestions should still be verified against the user's AWS configuration and official documentation before making changes to cloud resources.

Technology Stack

I built the application using the following technologies:
  • Python and Flask: Power the web application and backend API.
  • Groq API: Connects the application to the language model.
  • openai/gpt-oss-120b: The model used to generate troubleshooting responses through Groq.
  • HTML, CSS, and JavaScript: Provide the interactive chat interface.
  • Amazon EC2: Hosts the application on an Ubuntu instance.
  • Git and GitHub: Store and manage the project source code.
One important distinction is that the language model is accessed through Groq's API rather than Amazon Bedrock. Amazon EC2 is used to host the application, while Groq provides the AI inference service.

How the Application Works

The application follows a straightforward request-and-response architecture.
  1. User input: A user enters an AWS troubleshooting question in the browser.
  2. Frontend request: JavaScript sends the question to the Flask /api/chat endpoint.
  3. AI processing: The backend sends the question to the Groq API using the configured model.
  4. Response generation: The model produces a detailed troubleshooting explanation.
  5. Documentation references: The application includes relevant AWS documentation links.
  6. Frontend rendering: The response is returned as JSON and displayed in the chat interface.
The backend also exposes a /health endpoint, which I used to verify that the service was running and that the Groq API configuration was available.

Deploying AWS Cloud Buddy on Amazon EC2

One of the most valuable parts of this project was getting the application running on an actual cloud virtual machine instead of relying only on my local development environment.
I launched an Ubuntu-based Amazon EC2 instance and connected to it using SSH. After connecting, I cloned the GitHub repository, created a Python virtual environment, installed the required dependencies, and configured the environment variables needed by the application.
I then started the Flask application and configured the instance to accept requests on the application port for initial testing.
This deployment process helped me understand several practical cloud concepts:
  • Connecting to a Linux instance through SSH.
  • Deploying a Python application on a remote machine.
  • Managing dependencies with a virtual environment.
  • Configuring environment variables for API credentials.
  • Understanding how EC2 security group rules control network access.
  • Testing HTTP endpoints directly from the server.
  • Debugging the connection between a browser frontend and a backend API.
During testing, I initially encountered a “Failed to fetch” error in the frontend. Rather than assuming the AI service was broken, I tested the backend directly using curl.
The health endpoint returned HTTP 200, and a POST request to /api/chat also returned HTTP 200 with a generated troubleshooting response. These tests helped establish that the backend and AI integration were working, allowing me to focus on the browser-to-backend connection.

Screenshots From My Implementation

1. Connecting to the EC2 Instance Through SSH

Figure 1: Connecting to the remote EC2 instance and preparing the application environment.
This screenshot documents the remote deployment environment where I configured and tested AWS Cloud Buddy.

2. AWS Cloud Buddy Processing a Question

Figure 2: AWS Cloud Buddy receiving a user question and processing the request.
The chat interface provides a simple way to interact with the assistant. A user can submit a question and wait for the generated troubleshooting guidance.

3. Generated Troubleshooting Response

Figure 3: AWS Cloud Buddy returning a structured response with debugging steps and AWS documentation links.
In this test, I asked the assistant how to troubleshoot a Lambda 502 error. The response covered potential causes such as an invalid Lambda proxy response, unhandled exceptions, integration configuration, timeouts, and CloudWatch logs.
The backend returned the answer successfully as JSON, including the generated response and documentation references.

What I Learned

Building this project helped me connect application development with practical cloud deployment.
I gained hands-on experience with the process of moving a Python application from a local environment to an EC2 instance. I also learned the importance of checking each layer independently when debugging a web application: the frontend, backend API, external AI service, and cloud networking configuration.
Another important lesson was the value of structured API responses and health checks. A working homepage does not automatically mean that the application's API is working, and a successful backend request does not guarantee that the browser can reach the same endpoint.
Testing each component separately made the debugging process much more manageable.

Future Improvements

There are several improvements I would like to explore next:
  • Add AWS service-specific troubleshooting workflows.
  • Improve response validation and error handling.
  • Introduce a more robust retrieval mechanism for official AWS documentation.
  • Add automated tests for backend endpoints.
  • Deploy behind a production-grade application server and HTTPS-enabled reverse proxy.
  • Explore AWS-native AI services and integrations in a future version.
  • Add observability and usage monitoring to understand common troubleshooting requests.
These improvements would help make the application more reliable, secure, and useful for developers learning AWS.

Try the Project

GitHub repository:
https://github.com/THEyashkhange/aws_cloud_buddy 

Conclusion

AWS Cloud Buddy started as a practical way to combine AI application development with my cloud computing learning journey. By integrating a language model with a Flask application and deploying it on Amazon EC2, I built a working prototype that can answer AWS troubleshooting questions and provide relevant documentation links.
The project reinforced an important lesson: building an AI application is only one part of the process. Making it accessible, configuring the environment correctly, testing the API, and debugging connectivity are equally important.
I plan to keep improving AWS Cloud Buddy as I learn more about cloud architecture, deployment, and AI-powered developer tools.
If you are also learning AWS, I hope this project inspires you to build something practical, test it in a real environment, and share what you learn along the way.
Built as part of my AWS and AI learning journey.
# agents# aws-api# cloud-concepts
Any opinions in this article are those of the individual author and may not reflect the opinions of AWS.
Enjoyed reading this content? Let the author know!

Your likes, comments, shares, and saves help creators reach more builders.

Loading recommendations

Loading article