View Demo
·
Report Bug
·
Request Feature
This is the comprehensive project for CMPE 172 (Enterprise Software Development) at San Jose State University, for the Spring 2023 semester. This project is a multi-tiered, end-to-end system composed of several elements:
- A web-based application enabling cashiers to oversee their customers' orders (referred to as the Cashier's app)
- A mobile application facilitating payment for customer orders (termed as the Starbucks app)
- A Starbucks API responsible for processing requests coming from both the Cashier's and Starbucks apps
- A database designed to maintain records of orders and cards
The Cashier app and particularly the Starbucks API are designed for scalability, supported by multiple pods. They are capable of managing millions of user requests, and the load balancer assists in distributing these requests across the various pods - an external load balancer for the cashiers, and Kong's internal load balancer for all requests directed towards the Starbucks API.
However, there is a constraint regarding the number of active orders. Only one active order per register can be processed at a given time. Consequently, any request to place a new order in the register will be denied and remain unprocessed. This limitation isn't influenced by the number of pods, as all API pods draw data exclusively from the database and don't contain static data (following the removal of the activeOrders hashmap and subsequent code update).
This system could be enhanced by incorporating RabbitMQ. For example, we could initially send order placement requests to the RabbitMQ queue, where orders would be held pending execution. Then, the API would retrieve the next order from the queue for the register and set it as active, continuing this process until the queue is empty. Regrettably, due to not just time restrictions, but also being able to dequeue from the database, I wasn't able to implement RabbitMQ. Though, I gave it a try and uploaded RabbitMQ in GKE, which works as intended.
The rest of the necessary technology stack was utilized appropriately for the project, and the accompanying journal provides further details on the project's construction.
date May 2, 2023
commit 708d73d
topic Kong API
Kong is an API gateway that provides a unified entry point for all your APIs and microservices. It manages and secures APIs by providing features such as authentication, rate limiting, request/response transformations, load balancing, and more.
- It was difficult to be able to connect to Kong API, I had to first work on figuring out the configuration. I had problems using the correct endpoints and ports for the API to connect to my application, after figuring out that, I had problems with my get and post requests. POSTMAN was useful in configuring the parameters such as the correct headers to use in the body of the requests, but with practice and online resources I was able to test my requests against the API.
date May 3, 2023
commit d835760
topic RabbitMQ and GitHub Actions
I wanted to use RabbitMQ because it provides a resilient messaging queue system that aids in asynchronous communication within a software system. It allows me to decouple applications, enabling them to dispatch and receive data without needing immediate processing. This improves the responsiveness and scalability of my applications, by effectively managing data flow and preventing system overload.
Also, another thing I attemted to implement, but again, failed, is to utilize GitHub Actions as it offers a powerful solution for both Continuous Integration (CI) and Continuous Deployment (CD), streamlining the process of code updates and software releases. By automatically building, testing, and deploying applications whenever there's a change to the codebase, it reduces my manual workload. This leads to more consistent and frequent deployments, expediting product development, and enhancing software quality.
- Implementing both RabbitMQ and GitHub Actions posed distinct challenges. With RabbitMQ, the complexity arose from integrating it into the existing system architecture and ensuring its robust performance under high loads, whereas with GitHub Actions, setting up an efficient CI/CD pipeline and troubleshooting failed builds and deployments presented significant hurdles.
Therefore, I wasn't been able to accomplish these task while workin on my final project.
date May 4, 2023
commit bd1ff03
topic Admin Functionality
Admin functionality serves the crucial role of defining security configurations, such as authentication and authorization rules. It ensures that appropriate access controls are in place, thereby safeguarding sensitive data and functionalities. The admin login, specifically, is an essential part of this security framework, providing a secure way for administrators to access privileged functions and manage the application effectively.
Implementing Spring Security alongside a load balancer in Google Kubernetes Engine (GKE) presented notable challenges. Configuring both to work harmoniously, while maintaining secure user sessions across multiple pods, was complex. Furthermore, ensuring that the load balancer correctly distributed traffic without compromising the security protocols established by Spring Security added to the difficulties. Additionally, managing the routing of requests accurately to ensure that they reached the appropriate services, while maintaining session continuity in a load-balanced environment, also presented a significant challenge.
date May 5, 2023
commit f317f59
topic Cloud SQL
I wanted to leverage Google Cloud SQL because it provides a fully-managed relational database service for MySQL, PostgreSQL, and SQL Server. It handles the mundane tasks of database management, such as backups, patch management, and failover, allowing me to focus on developing applications. Moreover, its scalability, high availability, and security features make it an excellent choice for handling my application's data needs.
- Implementing Google Cloud SQL posed a few challenges, the most significant being fine-tuning the database for optimal performance while managing costs. Additionally, ensuring secure connections between the application and the database, as well as configuring the right access privileges without compromising security, were other complex aspects to navigate.
date May 6, 2023
commit f9ecad7
topic Stateless Session
Before deploying the Starbucks API code, I confirmed that the API is at least stateless, meaning it doesn't retain any data internally, such as arraylists or hashmaps. Instead, it should store all data within the database and an event queue, such as RabbitMQ. As part of your tasks, you'll need to elucidate the design and implementation, relating it back to the business logic. You'll also need to discuss the capabilities and constraints of your API in conjunction with all other components.
- Implementing stateless functionality to shift from using a hashmap to a database connection presented several challenges. The primary issue was managing the transition to a completely different data structure, which required significant code changes and retesting. Additionally, ensuring efficient and reliable database connections for every request, while maintaining high performance and scalability, was a complex task.
date May 8, 2023
commit a3dd2fa
topic Office Hours
I needed office hours where I had to meet with the professor to ask questions, seek clarification, and receive individualized support. They provided an opportunity to deepen my understanding of the course material, discuss assignments, and receive guidance, ultimately enhancing my learning experience.
date May 8, 2023
commit 24eb896
topic Postman Testing
I also used Postman to interact with the Kong API. By leveraging the environment variables I've set, I can seamlessly test and validate various API endpoints, ensuring their functionality and performance. Postman enables me to send requests, receive responses, and analyze the API's behavior, ultimately helping me ensure the reliability and effectiveness of my Kong API implementation.
Firstly, managing the environment variables can be complex, especially when dealing with different environments or configurations. Secondly, understanding the intricacies of the Kong API and its specific authentication methods requires additional research and knowledge. Lastly, accurately simulating various scenarios and handling edge cases during testing can be time-consuming and require meticulous attention to detail. Eventually, I changed current variables to meet Kong API requirements
date May 10, 2023
commit 9b345fc
topic Deployment Testing
Scalable platform for running containerized applications offered service discovery and load balancing, which helped in managing my applications more efficiently. Moreover, its ability to scale applications based on traffic or custom metrics ensures optimal resource utilization and application performance.
Main challenges I have faced were:
- Configuration Errors: Pulling from Docker Hub in my deployment yaml with wrong tag number
- Networking Issues: I had to google "my ip address" and paste it in SQL networking to be able to access
date May 11, 2023
commit 9715e2f
topic Starbucks Cashier
Cashier Web App as it serves as a user-friendly platform for cashiers to manage customer orders efficiently. It provides an intuitive interface for order input, modification, and tracking, streamlining the cashiers' workflow. Additionally, its integration with the backend system and the Starbucks API ensures seamless, real-time updates and coordination with the customer-facing Starbucks app.
- Switching the Cashier Web App from localhost to the Kong API on Google Kubernetes Engine (GKE) posed several challenges. The major hurdle was ensuring a smooth transition and maintaining seamless communication between the web app and the API in the new environment. Additionally, dealing with potential networking and security issues related to the shift to a cloud-based solution was another complex aspect of the transition. Implementing the feature to select a drink, milk, and size in the Cashier Web App also presented its own set of challenges. Designing and integrating these additional user interfaces while ensuring they correctly interact with the backend system and provide a smooth user experience was a complex task.
date May 13, 2023
commit f9de2a9
topic Final Testing
That concludes the project! I've opted not to include screenshots of every individual Postman request, as they've been functioning flawlessly. I take great pride in the work I've accomplished, and if you're interested in a brief demonstration of the project, you can find it at the beginning of the readme.
Over the course of the project, I am proud to announce that I am attempting two awards, namely the Enterprise Quality Award: Quality of Code, Documentation, and Design Notes and the Enterprise Architecture Award: Innovation using Enterprise Architecture and Cloud Scaling Patterns. Here is a description of the work I've done towards these awards:
Enterprise Quality Award: Quality of Code, Documentation, and Design Notes For the Enterprise Quality Award, my primary focus was to ensure high-quality code, comprehensive documentation, and clear design notes. I maintained these standards throughout the project lifecycle and made the repository accessible via GitHub.
Quality of Code: My code follows the best practices, such as consistent naming conventions, modular design, and comprehensive comments. It is clean, efficient, and easy to understand. I adhered to the DRY (Don't Repeat Yourself) principle, ensuring that the functions were reusable and the code was efficient.
Documentation: I have provided a comprehensive README.md file that covers everything from project setup, configuration, usage, and testing. In addition, every piece of code, major function, and class has been thoroughly documented to ensure clear understanding and ease of use.
Design Notes: I maintained a clear log of the design choices made during the project development in a separate README.md file. This covers the rationale behind each significant decision and architectural choice, ensuring transparency and clarity.
Enterprise Architecture Award: Innovation using Enterprise Architecture and Cloud Scaling Patterns For the Enterprise Architecture Award, my focus was on utilizing innovative techniques and patterns to ensure the project's scalability, resilience, and high availability on the cloud.
Enterprise Architecture: I leveraged microservices architecture to ensure that each component of the application was independently deployable, scalable, and loosely coupled. This design allows for better fault isolation, easier debugging, and the ability to use different technologies for different services.
Cloud Scaling Patterns: I employed load balancing strategies to manage the application load. As a result, the application can seamlessly scale up or down based on demand, ensuring efficient resource use and high availability. When refreshing the page, it does not move to another pod because my ingress detects client ip
I am excited to share these innovations and quality standards I've maintained throughout my project, and I look forward to the possibility of being recognized for these efforts.