I found a simple banking application on GitHub and used it as the base for my learning project. I did not build the application itself, but I did take it through the DevOps journey — containerizing it, deploying it on Kubernetes, and setting up infrastructure on AWS with Terraform.
I wanted to improve my understanding of how an application moves from a local project to a real environment where it can actually run and be used.
Why I Chose This Project
I wanted a project that would help me understand DevOps in a practical way. A banking app was a good choice because it already had a clear purpose and some important features like login, dashboard, deposits, withdrawals, and transactions.
The interesting part for me was not just the app itself. It was the journey of taking that app and making it ready for deployment. Instead of building a small demo app from zero, I focused on:
- Packaging the app with Docker
- Deploying it with Kubernetes
- Managing the database
- Provisioning infrastructure using Terraform
The First Step: Understanding the Application
Before doing anything with Docker or Kubernetes, I took time to understand the project structure. The app was built using Java and Spring Boot, and it used MySQL for data storage.
That was already enough for me to understand that this project could become a good example of a multi-tier application. Since the original README wasn't very detailed, I cloned the repository and created a detailed README from scratch to document my process.
Dockerizing the Application
Once I understood the app, the next step was to containerize it. I wrote a Dockerfile to package the environment and the application, created a Docker image, and pushed it to my Docker Hub registry. This made the application portable and ready for any environment.
Moving to Kubernetes
After Docker, the next step was Kubernetes. Honestly, this part felt a little intimidating at first.
I used Kubernetes to deploy both the application and the MySQL database. This was a very important experience because it showed me that deployment is not just about “running an app.” It is also about:
- Ensuring the app can connect to the database.
- Persisting data so it isn't lost when a container restarts.
- Keeping the service available to users.
I learned that databases need more careful planning than stateless applications. You need to think about storage, persistence, and configuration.
Terraform and AWS: The Infrastructure Part
After Docker and Kubernetes, I wanted to learn how infrastructure could be created using code (IaC). That is where Terraform came in.
I used Terraform to provision the AWS resources for the project, including:
- VPC & Subnets: For networking logic.
- Internet Gateway: To allow traffic.
- EKS Cluster: To run our Kubernetes nodes.
- IAM Roles & Security Groups: To manage permissions and security.
This part taught me that DevOps is just as much about the environment as it is about the application.
What I Learned From This Project
1. You do not need to start from zero
One of the best things about this project was that I did not need to build the whole application myself. By using an existing app, I could focus 100% on the deployment and infrastructure side.
2. Troubleshooting is normal
There were many times when things did not work—database connection errors or service exposure issues. These frustrations were actually where the most learning happened.
3. Security matters
I gained a basic understanding of why secrets, permissions, and access control are vital in real-world cloud environments.
Final Thoughts
If you are a beginner in DevOps, I think this kind of project is a great place to start. You do not need to build everything yourself. You can take an existing project and focus on improving the deployment and infrastructure side of it.
Multi-Tier Bank Application on Kubernetes
A full-stack banking application deployed using modern DevOps practices. This project demonstrates how to build a Spring Boot web app, containerize it with Docker, deploy it on Kubernetes, and provision an AWS EKS environment with Terraform.
Project Overview
This repository contains a simple multi-tier banking web application with:
- a Spring Boot backend
- a MySQL database
- Docker-based containerization
- Kubernetes manifests for deployment
- Terraform infrastructure as code for AWS EKS
- RBAC setup guidance for CI/CD automation
The goal of this project is to showcase a practical end-to-end DevOps workflow from application development to cloud deployment.
What the Application Does
Users can:
- register an account
- log in securely
- view their dashboard
- deposit funds
- withdraw funds
- transfer money to another user
- view transaction history
The application is built with Spring Boot, Spring Security, Thymeleaf, and MySQL.
Architecture
The project follows a multi-tier architecture:
- Frontend: Thymeleaf-based web UI
- Backend: Spring…
Top comments (0)