Loading repository data…
vinod-kha / repository
This cloud-native web application is built using a mix of technologies. It's designed to be accessible to users via the internet, allowing them to vote for their preferred programming language out of six choices: C#, Python, JavaScript, Go, Java, and NodeJS.
A transparent discovery signal based on current public GitHub metadata.
This score does not audit code, security, maintainers, documentation quality, or suitability. Verify the repository and its current documentation before adoption.
This cloud-native web application is built using a mix of technologies. It's designed to be accessible to users via the internet, allowing them to vote for their preferred programming language out of six choices: C#, Python, JavaScript, Go, Java, and NodeJS.
Frontend: The frontend of this application is built using React and JavaScript. It provides a responsive and user-friendly interface for casting votes.
Backend and API: The backend of this application is powered by Go (Golang). It serves as the API handling user voting requests. MongoDB is used as the database backend, configured with a replica set for data redundancy and high availability.
To deploy and manage this application effectively, we leverage Kubernetes and a variety of its resources:
Namespace: Kubernetes namespaces are utilized to create isolated environments for different components of the application, ensuring separation and organization.
Secret: Kubernetes secrets store sensitive information, such as API keys or credentials, required by the application securely.
Deployment: Kubernetes deployments define how many instances of the application should run and provide instructions for updates and scaling.
Service: Kubernetes services ensure that users can access the application by directing incoming traffic to the appropriate instances.
StatefulSet: For components requiring statefulness, such as the MongoDB replica set, Kubernetes StatefulSets are employed to maintain order and unique identities.
PersistentVolume and PersistentVolumeClaim: These Kubernetes resources manage the storage required for the application, ensuring data persistence and scalability.
Creating and deploying this cloud-native web voting application with Kubernetes offers a valuable learning experience. Here are some key takeaways:
Containerization: Gain hands-on experience with containerization technologies like Docker for packaging applications and their dependencies.
Kubernetes Orchestration: Learn how to leverage Kubernetes to efficiently manage, deploy, and scale containerized applications in a production environment.
Microservices Architecture: Explore the benefits and challenges of a microservices architecture, where the frontend and backend are decoupled and independently scalable.
Selected from shared topics, language and repository description—not editorial ratings.
Shwetha157 /
This project is a fully serverless web application built on AWS, designed for taking and managing personal notes. It demonstrates the use of key AWS services such as **Amplify**, **API Gateway**, **Lambda**, **DynamoDB**, and **IAM** to create a secure, scalable, and cost-effective cloud-native application.
27/100 healthabubakarsajidcloud-hue /
A cloud-native serverless portfolio application built on AWS using Infrastructure as Code (IaC) principles and modern DevOps practices. This project demonstrates scalable serverless architecture with automated infrastructure provisioning, API integration, static web hosting, and cloud automation using Terraform.
51/100 healthDatabase Replication: Understand how to set up and manage a MongoDB replica set for data redundancy and high availability.
Security and Secrets Management: Learn best practices for securing sensitive information using Kubernetes secrets.
Stateful Applications: Gain insights into the nuances of deploying stateful applications within a container orchestration environment.
Persistent Storage: Understand how Kubernetes manages and provisions persistent storage for applications with state.
By working through this project, you'll develop a deeper understanding of cloud-native application development, containerization, Kubernetes, and the various technologies involved in building and deploying modern web applications.
Create EKS cluster with NodeGroup (2 nodes of t2.medium instance type) Create EC2 Instance t2.micro (Optional)
##IAM role for ec2
{
"Version": "2012-10-17",
"Statement": [{
"Effect": "Allow",
"Action": [
"eks:DescribeCluster",
"eks:ListClusters",
"eks:DescribeNodegroup",
"eks:ListNodegroups",
"eks:ListUpdates",
"eks:AccessKubernetesApi"
],
"Resource": "*"
}]
}
Install Kubectl:
curl -O https://s3.us-west-2.amazonaws.com/amazon-eks/1.24.11/2023-03-17/bin/linux/amd64/kubectl
chmod +x ./kubectl
sudo cp ./kubectl /usr/local/bin
export PATH=/usr/local/bin:$PATH
Install AWScli:
curl "https://awscli.amazonaws.com/awscli-exe-linux-x86_64.zip" -o "awscliv2.zip"
unzip awscliv2.zip
sudo ./aws/install
Once the Cluster is ready run the command to set context:
aws eks update-kubeconfig --name EKS_CLUSTER_NAME --region us-west-2
To check the nodes in your cluster run
kubectl get nodes
If using EC2 and getting the "You must be logged in to the server (Unauthorized)" error, refer this: https://repost.aws/knowledge-center/eks-api-server-unauthorized-error
Clone the github repo
git clone https://github.com/N4si/K8s-voting-app.git
Create Vinod Namespace
kubectl create ns vinod
kubectl config set-context --current --namespace vinod
MONGO Database Setup
To create Mongo statefulset with Persistent volumes, run the command in manifests folder:
kubectl apply -f mongo-statefulset.yaml
Mongo Service
kubectl apply -f mongo-service.yaml
Create a temporary network utils pod. Enter into a bash session within it. In the terminal run the following command:
kubectl run --rm utils -it --image praqma/network-multitool -- bash
Within the new utils pod shell, execute the following DNS queries:
for i in {0..2}; do nslookup mongo-$i.mongo; done
Note: This confirms that the DNS records have been created successfully and can be resolved within the cluster, 1 per MongoDB pod that exists behind the Headless Service - earlier created.
Exit the utils container
exit
On the mongo-0 pod, initialise the Mongo database Replica set. In the terminal run the following command:
cat << EOF | kubectl exec -it mongo-0 -- mongo
rs.initiate();
sleep(2000);
rs.add("mongo-1.mongo:27017");
sleep(2000);
rs.add("mongo-2.mongo:27017");
sleep(2000);
cfg = rs.conf();
cfg.members[0].host = "mongo-0.mongo:27017";
rs.reconfig(cfg, {force: true});
sleep(5000);
EOF
Note: Wait until this command completes successfully, it typically takes 10-15 seconds to finish, and completes with the message: bye
To confirm run this in the terminal:
kubectl exec -it mongo-0 -- mongo --eval "rs.status()" | grep "PRIMARY\|SECONDARY"
Load the Data in the database by running this command:
cat << EOF | kubectl exec -it mongo-0 -- mongo
use langdb;
db.languages.insert({"name" : "csharp", "codedetail" : { "usecase" : "system, web, server-side", "rank" : 5, "compiled" : false, "homepage" : "https://dotnet.microsoft.com/learn/csharp", "download" : "https://dotnet.microsoft.com/download/", "votes" : 0}});
db.languages.insert({"name" : "python", "codedetail" : { "usecase" : "system, web, server-side", "rank" : 3, "script" : false, "homepage" : "https://www.python.org/", "download" : "https://www.python.org/downloads/", "votes" : 0}});
db.languages.insert({"name" : "javascript", "codedetail" : { "usecase" : "web, client-side", "rank" : 7, "script" : false, "homepage" : "https://en.wikipedia.org/wiki/JavaScript", "download" : "n/a", "votes" : 0}});
db.languages.insert({"name" : "go", "codedetail" : { "usecase" : "system, web, server-side", "rank" : 12, "compiled" : true, "homepage" : "https://golang.org", "download" : "https://golang.org/dl/", "votes" : 0}});
db.languages.insert({"name" : "java", "codedetail" : { "usecase" : "system, web, server-side", "rank" : 1, "compiled" : true, "homepage" : "https://www.java.com/en/", "download" : "https://www.java.com/en/download/", "votes" : 0}});
db.languages.insert({"name" : "nodejs", "codedetail" : { "usecase" : "system, web, server-side", "rank" : 20, "script" : false, "homepage" : "https://nodejs.org/en/", "download" : "https://nodejs.org/en/download/", "votes" : 0}});
db.languages.find().pretty();
EOF
Create Mongo secret:
kubectl apply -f mongo-secret.yaml
API Setup
Create GO API deployment by running the following command:
kubectl apply -f api-deployment.yaml
Expose API deployment through service using the following command:
kubectl expose deploy api \
--name=api \
--type=LoadBalancer \
--port=80 \
--target-port=8080
Next set the environment variable:
{
API_ELB_PUBLIC_FQDN=$(kubectl get svc api -ojsonpath="{.status.loadBalancer.ingress[0].hostname}")
until nslookup $API_ELB_PUBLIC_FQDN >/dev/null 2>&1; do sleep 2 && echo waiting for DNS to propagate...; done
curl $API_ELB_PUBLIC_FQDN/ok
echo
}
Test and confirm that the API route URL /languages, and /languages/{name} endpoints can be called successfully. In the terminal run any of the following commands:
curl -s $API_ELB_PUBLIC_FQDN/languages | jq .
curl -s $API_ELB_PUBLIC_FQDN/languages/go | jq .
curl -s $API_ELB_PUBLIC_FQDN/languages/java | jq .
curl -s $API_ELB_PUBLIC_FQDN/languages/nodejs | jq .
If everything works fine, go ahead with Frontend setup.
{
API_ELB_PUBLIC_FQDN=$(kubectl get svc api -ojsonpath="{.status.loadBalancer.ingress[0].hostname}")
echo API_ELB_PUBLIC_FQDN=$API_ELB_PUBLIC_FQDN
}
Frontend setup
Create the Frontend Deployment resource. In the terminal run the following command:
kubectl apply -f frontend-deployment.yaml
Create a new Service resource of LoadBalancer type. In the terminal run the following command:
kubectl expose deploy frontend \
--name=frontend \
--type=LoadBalancer \
--port=80 \
--target-port=8080
Confirm that the Frontend ELB is ready to recieve HTTP traffic. In the terminal run the following command:
{
FRONTEND_ELB_PUBLIC_FQDN=$(kubectl get svc frontend -ojsonpath="{.status.loadBalancer.ingress[0].hostname}")
until nslookup $FRONTEND_ELB_PUBLIC_FQDN >/dev/null 2>&1; do sleep 2 && echo waiting for DNS to propagate...; done
curl -I $FRONTEND_ELB_PUBLIC_FQDN
}
Generate the Frontend URL for browsing. In the terminal run the following command:
echo http://$FRONTEND_ELB_PUBLIC_FQDN
Test the full end-to-end cloud native application
Using your local workstation's browser - browse to the URL created in the previous output.
After the voting application has loaded successfully, vote by clicking on several of the +1 buttons, this will generate AJAX traffic which will be sent back to the API via the API's assigned ELB.
Query the MongoDB database directly to observe the updated vote data. In the terminal execute the following command:
kubectl exec -it mongo-0 -- mongo langdb --eval "db.languages.find().pretty()"
In this Project, you learnt how to deploy a cloud native application into EKS. Once deployed and up and running, you used your local workstation's browser to test out the application. You later confirmed that your activity within the application generated data which was captured and recorded successfully within the MongoDB ReplicaSet back end within the cluster.
jacksonitoro /
This project shows how to containerize a Python FastAPI web application, package it into a Docker container, and then use CI/CD pipelines to automatically deploy it to AWS EC2 instances.
34/100 healthjeenwalvaishali /
Welcome to the Cloud-Native Web Application project repository! 🚀 This coursework project, showcases the implementation of a robust backend API adhering to RESTful principles. The focus is on cloud-native architecture, AWS services, and best practices in software engineering.
27/100 healthShivrajjjjj /
This repository demonstrates a .NET 8 backend API with a static frontend UI, fully containerized and deployed to AWS ECS using a CI/CD pipeline. It combines modern web development with cloud-native deployment practices.
34/100 healthKonaKarthik /
This project demonstrates a complete end-to-end serverless application built and deployed using Amazon Web Services (AWS). It showcases how modern cloud-native applications can run without managing servers, using fully managed services such as AWS Lambda, API Gateway, DynamoDB, and IAM.
34/100 health