Atmosphere Analyzer is a comprehensive environmental monitoring system designed to simulate real-time sensor data using Python. It seamlessly integrates AWS S3 for scalable and reliable data storage, while leveraging AWS Lambda for efficient, serverless data processing. The system's backend API, built with Django, organizes and serves environmental data through RESTful endpoints, ensuring robust data access. The frontend, developed with React, presents these metrics on an interactive dashboard, offering users a clear and intuitive visualization of environmental trends. The project is now deployment-ready, using Render to host the Django API and a static React build, with Gunicorn, WhiteNoise, and CORS configuration for production stability and cross-origin access.
This project empowers data-driven decision-making for sustainable resource management by delivering actionable insights through smart data visualization.
Live Application: https://atmosphere-analyzer-dashboard.onrender.com/
- Project Overview
- Architecture
- Technologies
- Setup and Installation
- Usage
- Deployment
- Future Enhancements
- Contributing
- Contact
Atmosphere Analyzer enables real-time monitoring and visualization of environmental metrics through a robust architecture that simulates, processes, and delivers data efficiently. Designed for scalability and insight-driven analytics, the system models sensor data to help users track environmental changes over time, providing actionable insights for data-driven decision-making.
- Data Simulation (Python): Simulates sensor data (e.g., temperature, humidity) to mimic real-world readings.
- Data Storage (AWS S3): Utilizes AWS S3 for scalable and durable storage of environmental metrics.
- Data Processing (AWS Lambda): Processes incoming data using AWS Lambda, enabling real-time processing without server management.
- Backend API (Django): Organizes and serves data to the frontend through RESTful endpoints, managing data access efficiently.
- Frontend Visualization (React): The interactive React dashboard fetches and visualizes data in real-time, enhancing user engagement.
- Deployment (Render): Django runs with Gunicorn, static assets are served via WhiteNoise, and the React app is built and deployed as a static site with environment-based API configuration and CORS support.
- Python: For data simulation and AWS Lambda processing.
- AWS (S3, Lambda): Provides scalable storage and serverless data processing capabilities.
- Django: Facilitates API creation and data management.
- React: Powers interactive data visualization.
- Django REST Framework: Establishes REST API endpoints for seamless data access.
- Render: Hosts the Django API and the React static build for deployment.
- Gunicorn: Production WSGI server for Django.
- WhiteNoise: Serves static files in production for the Django backend.
- django-cors-headers: Enables CORS configuration for the frontend-to-backend requests.
- Chart.js + react-chartjs-2: Powers the dashboard visualizations.
- Axios: Handles API requests from the React frontend.
- Python 3.x and Django installed on your machine
- Node.js and npm for the React frontend
- AWS CLI configured with access to S3 and Lambda
- (Optional for deployment) Render account and CLI or dashboard access
- Clone the Repository
git clone https://github.com/mariarodr1136/AtmosphereAnalyzer.git cd AtmosphereAnalyzer - Backend Setup (Django)
- Navigate to the backend directory:
cd backend - Install dependencies:
pip install -r requirements.txt
- Configure AWS S3 settings in Django.
- Start the Django Server:
python manage.py runserver
- Frontend Setup (React)
- Navigate to the frontend directory:
cd frontend - Install dependencies:
npm install
- Start the React development server:
npm start
- AWS Lambda Setup
- Create a Lambda function for data processing and configure it to store data in S3.
- Render Deployment Setup (Optional)
- Configure environment variables for the backend (e.g.,
DJANGO_SECRET_KEY,DEBUG,ALLOWED_HOSTS,CORS_ALLOWED_ORIGINS) and for the frontend (REACT_APP_API_URL). - Use the provided
render.yamlto deploy the Django API (Gunicorn + WhiteNoise) and the React static site.
Atmosphere.Analyzer.mov
- Simulate Sensor Data: Run the Python script to simulate data transmission to the Django API.
- View Data on Dashboard: Access the React dashboard to visualize real-time environmental metrics sourced from the API.
- Backend (Django): Deploy on Render with Gunicorn and WhiteNoise, or use AWS Elastic Beanstalk / EC2 for scalable hosting.
- Frontend (React): Deploy the static build on Render, or use AWS Amplify / S3 static site hosting for reliable frontend delivery.
- Advanced Data Analytics: Integrate machine learning models to predict environmental trends.
- User Authentication: Implement user management for secure, personalized data access.
- Expanded Sensor Metrics: Add more simulated metrics like air quality and light levels.
Feel free to submit issues or pull requests for improvements or bug fixes. You can also open issues to discuss potential changes or enhancements. All contributions are welcome to enhance the app’s features or functionality!
To contribute, please follow these steps:
- Fork the repository.
- Create a new branch for your feature or bug fix:
git checkout -b feat/your-feature-name
- Alternatively, for bug fixes:
git checkout -b fix/your-bug-fix-name
- Make your changes and run all tests before committing the changes and make sure all tests are passed.
- After all tests are passed, commit your changes with descriptive messages:
git commit -m 'add your commit message' - Push your changes to your forked repository:
git push origin feat/your-feature-name.
- Submit a pull request to the main repository, explaining your changes and providing any necessary details.
If you have any questions or feedback, feel free to reach out at mrodr.contact@gmail.com.